package com.renjun.smweb.service.RegisterService.impl;

import com.alibaba.fastjson.JSONObject;
import com.renjun.smweb.commons.componet.BaseDaoComponent;
import com.renjun.smweb.commons.componet.FileIOComponent;
import com.renjun.smweb.commons.enums.EOperators;
import com.renjun.smweb.commons.enums.EStandTables;
import com.renjun.smweb.commons.global.DataDict;
import com.renjun.smweb.commons.global.DataMap;
import com.renjun.smweb.commons.global.FileInfoPo;
import com.renjun.smweb.commons.util.*;
import com.renjun.smweb.dao.bean.*;
import com.renjun.smweb.dao.pojo.LoginInfo;
import com.renjun.smweb.exceptions.AddRegisterSchoolException;
import com.renjun.smweb.exceptions.BaseException;
import com.renjun.smweb.exceptions.DictIsNotFoundException;
import com.renjun.smweb.service.CommonService.CommonService;
import com.renjun.smweb.service.RegisterService.RegisterService;
import com.renjun.smweb.service.RuleValidationService;
import com.itextpdf.text.DocumentException;
import com.renjun.smweb.exceptions.FileTypeNotFoundException;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.*;

/**
 * Created by RenJun on 2017/2/21.
 */
@Service
public class RegisterServiceImpl implements RegisterService {
    @Autowired
    private BaseDaoComponent baseDaoComponent;

    @Resource
    private CommonService commonService;

    @Resource
    private RuleValidationService ruleValidationService;

    @Override
    public JSONObject queryRegisterList(Map<String, Object> params) throws SQLException {
        return ResponseUtils.createSuccessResponseBody("登记成功",getRegisterList(params));
    }

    /**
     * 查询列表封装，好处为：导出的时候需要使用到.
     * @param params
     * @return
     * @throws SQLException
     */
    private  List<Map<String, Object>> getRegisterList(Map<String,Object> params,String...tables) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) params.remove("userinfo");
        String defaultTable = "V_M6_RegisterList_xlj";
        //区管视图
        String loginType = loginInfo.getRoletype();
        if("2".equals(loginType)) {
            defaultTable = "V_M6_RegisterDistrictCode_xlj";
        }
        //登记表视图
        if(tables!=null&&tables.length!=0){
            defaultTable = tables[0];
        }

        String studentId = (String) params.remove("id");//勾选的id
        QueryParams qeuryRegisterList = QueryParams.createQueryParams(defaultTable);
        if (!BaseChecks.hasEmptyStr(studentId)) {
            if (studentId.contains(",")) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("id", EOperators.包含, studentId.split(",")));
            } else {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("id", studentId));
            }
        }

        String name = (String) params.remove("xm");
        if (!BaseChecks.hasEmptyStr(name)) {//模糊查询
            //判断是否为中文
            if(BaseChecks.isChineseChar(name)){
                //是，空格全部替换
                name = name.replaceAll(" ","");
            }else{
                //否，替换两端空格
                name = BaseChecks.bothEndsStr(name);
            }
            qeuryRegisterList.addQueryParams(Parameter.createParameter("xm", EOperators.类似, name));
        }
        //TODO 注意，要改动，户口省份为，和不为 是：包含和不包含。2017年2月22日09:35:23
        String hksfw = (String) params.remove("hksfscope");
        //"hksfscope" -> "1"
        String hksf = (String) params.remove("hksf");
        if("1".equals(hksfw)) {
            if(!BaseChecks.hasEmptyStr(hksf)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hksf", EOperators.包含, hksf));
            }
        }
        if("0".equals(hksfw)) {
            if(!BaseChecks.hasEmptyStr(hksf)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hksf", EOperators.不包含, hksf));
            }
        }
        //TODO 户口区县同理"hkqxscope" -> "1"
        String  hkqxw = (String) params.remove("hkqxscope");
        String hkqx = (String) params.remove("hkqx");
        if("1".equals(hkqxw)) {
            if(!BaseChecks.hasEmptyStr(hkqx)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hkqx", EOperators.包含, hkqx));
            }
        }
        if("0".equals(hkqxw)) {
            if(!BaseChecks.hasEmptyStr(hkqx)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hkqx", EOperators.不包含, hkqx));
            }
        }
        String  hkcityscope = (String) params.remove("hkcityscope");
        String hkcity = (String) params.remove("hkcity");
        if("1".equals(hkcityscope)) {
            if(!BaseChecks.hasEmptyStr(hkcity)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hkcity", EOperators.包含, hkcity));
            }
        }
        if("0".equals(hkcityscope)) {
            if(!BaseChecks.hasEmptyStr(hkcity)) {
                qeuryRegisterList.addQueryParams(Parameter.createParameter("hkcity", EOperators.不包含, hkcity));
            }
        }
        qeuryRegisterList.addQueryParamsByMap(CollectionUtils.removeEmptyKeyByParams(params));
        try {
            qeuryRegisterList.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> registerList = baseDaoComponent.selectDataByParams(qeuryRegisterList);
        return registerList;
    }


    @Override
    public JSONObject addRegister(Map<String, Object> params) throws SQLException, BaseException, ParseException {
       //首先校验是否在时间范围内.
        Map<String,Object> errorMap = new HashMap<>();
        params.put("opentype","1");//登记
        if(commonService.checkDate(params)){
            errorMap.put("message","不在登记时间范围内");
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            return  rs;
        }
        params.put("xzzsf","310100");
        String check = ruleValidationService.checkAddRegisterStudentJs(params);//新增的校验
        if(check.contains("__")) {
            errorMap.put("message",check);
            errorMap.put("status","error");
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            rs.put("message",check);
            return  rs;
        }
        //转换
        Map<String, Object> registerMap = getRegister(params);
        registerMap.put("checkstatus","1");//新增进来的全部是校验通过的
        //新增
        insertRegister(registerMap);
        return  ResponseUtils.createSuccessResponseBody("登记成功");
    }

    /**
     * 插入登记表
     * @param register
     * @throws SQLException
     */
    @Transactional
    private void insertRegister(Map<String,Object> register) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) register.remove("userinfo");
        InsertParams insertRegister = InsertParams.createInsertParams("T_BAOMINGLUQUINFO");
        insertRegister.addParamsForMap(register);
        try {
            insertRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.insertDataByParams(insertRegister);
        //新增记录需要进入操作记录表
        insertBaoMingRec(register,loginInfo);
        //插入到报名信息表---金山区只能插入1条，虹口区可以重复插入.
        insertBaoMing(register,loginInfo);
    }

    /**
     * 新增报名登记信息表
     * @param register
     * @param loginInfo
     */
    private void insertBaoMing(Map<String,Object> register,LoginInfo loginInfo) throws SQLException {
        Map<String,Object> registerMap = new HashMap<>();
        String date = Format.getDateTime();
        registerMap.put("id",UUID.randomUUID().toString());//唯一主键
        registerMap.put("bmid",register.get("id"));//基础信息表的学生id
        registerMap.put("bmxx",register.get("djxx"));//报名学校值登记学校
        registerMap.put("bmsj",date);//添时间
        registerMap.put("deleted","0");//删除位，默认为0
        registerMap.put("adduserid",loginInfo.getId());//添加人ID
        registerMap.put("addtime",date);//添时间
        InsertParams insertBaoMing = InsertParams.createInsertParams("t_baominginfo");
        insertBaoMing.addParamsForMap(registerMap);
        try {
            insertBaoMing.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.insertDataByParams(insertBaoMing);
    }

    /**
     * 日期转换
     * @param params
     * @return
     */
    private Map<String,Object> getDate(Map<String,Object> params) {
        String csrq = (String) params.get("csrq");
        if(!BaseChecks.hasEmptyStr(csrq)) {
            if(csrq.contains("-")) {
                csrq = csrq.replace("-","");
            }
        }
        params.put("csrq",csrq);//出生日期
        String zjyxq = (String) params.get("zjyxq");
        if(!BaseChecks.hasEmptyStr(zjyxq)) {
            if(zjyxq.contains("-")) {
                zjyxq = zjyxq.replace("-","");
            }
        }
        params.put("zjyxq",zjyxq);//证件有效期

        String jzzyxq = (String)params.get("jzzyxq");
        if(jzzyxq.contains("-")) {
            jzzyxq = jzzyxq.replace("-","");
        }
        params.put("jzzyxq",jzzyxq);//居住证有效期
        String hjdjr = (String)params.get("hjdjr");
        if(!BaseChecks.hasEmptyStr(hjdjr)) {
            if(hjdjr.contains("-")) {
                hjdjr = hjdjr.replace("-","");
            }
        }
        params.put("hjdjr",hjdjr);//户籍登记日

        String djrq = (String)params.get("djrq");
        if(!BaseChecks.hasEmptyStr(djrq)) {
            if(djrq.contains("-")) {
                djrq = djrq.replace("-","");
            }
        }
        params.put("djrq",djrq);//(产权房)登记日期
        String qzrq = (String)params.get("qzrq");
        if(!BaseChecks.hasEmptyStr(qzrq)) {
            if(qzrq.contains("-")) {
                qzrq = qzrq.replace("-","");
            }
        }
        params.put("qzrq",qzrq);//(租赁)起租日期
        String cjzfzrq = (String)params.get("cjzfzrq");
        if(!BaseChecks.hasEmptyStr(cjzfzrq)) {
            if(cjzfzrq.contains("-")) {
                cjzfzrq = cjzfzrq.replace("-","");
            }
        }
        params.put("cjzfzrq",cjzfzrq);//残疾证发证日期
        String jhrjzzyxq = (String)params.get("jhrjzzyxq");
        if(!BaseChecks.hasEmptyStr(jhrjzzyxq)) {
            if(jhrjzzyxq.contains("-")) {
                jhrjzzyxq = jhrjzzyxq.replace("-","");
            }
        }
        params.put("jhrjzzyxq",jhrjzzyxq);//监护人居住证有效期
        String jhrlssj = (String)params.get("jhrlssj");
        if(!BaseChecks.hasEmptyStr(jhrlssj)) {
            if(jhrlssj.contains("-")) {
                jhrlssj = jhrlssj.replace("-","");
            }
        }
        params.put("jhrlssj",jhrlssj);//监护人临时居住证办证时间
        return params;
    }

    /**
     * 转换为登记表参数
     * @param params
     * @return
     */
    private Map<String,Object> getRegister(Map<String,Object> params) {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        Map<String,Object> registerMap = new HashMap<>();
        String djlx = "1";//为2的时候为区管，学校管理员默认为1
        if("2".equals(loginInfo.getRoletype())) {
            djlx="2";
        }
        registerMap.put("hkxz",params.get("hkxz"));
        registerMap.put("wsshkdz",params.get("wsshkdz"));
        registerMap.put("hkcity",params.get("hkcity"));
        registerMap.put("userinfo",loginInfo);
        registerMap.put("djqx",loginInfo.getDistrictcode());//登记区县
        registerMap.put("djlx",djlx);//登记类型
        registerMap.put("id", UUID.randomUUID().toString());//ID唯一标识
        registerMap.put("xm",params.get("xm"));//姓名

        String csrq = (String) params.get("csrq");
        if(!BaseChecks.hasEmptyStr(csrq)) {
            if(csrq.contains("-")) {
                csrq = csrq.replace("-","");
            }
        }
        registerMap.put("csrq",csrq);//出生日期
        registerMap.put("xb",params.get("xb"));//性别是否需要转换
        registerMap.put("sfzlx",params.get("sfzlx"));//身份证类型
        registerMap.put("sfzjh",params.get("sfzjh"));//证件号码
        String zjyxq = (String) params.get("zjyxq");
        if(!BaseChecks.hasEmptyStr(zjyxq)) {
            if(zjyxq.contains("-")) {
                zjyxq = zjyxq.replace("-","");
            }
        }
        registerMap.put("zjyxq",zjyxq);//证件有效期
        registerMap.put("jzzlx",params.get("jzzlx"));//居住证类型
        registerMap.put("jzzhm",params.get("jzzhm"));//居住证号码
        String jzzyxq = (String)params.get("jzzyxq");
        if(jzzyxq.contains("-")) {
            jzzyxq = jzzyxq.replace("-","");
        }
        registerMap.put("jzzyxq",jzzyxq);//居住证有效期
        registerMap.put("mz",params.get("mz"));//名族
        registerMap.put("gjdq",params.get("gjdq"));//国家地区
        registerMap.put("jkzk",params.get("jkzk"));//健康状况
        registerMap.put("hjlb",params.get("hjlb"));//户籍类别
        registerMap.put("fnhklx",params.get("fnhklx"));//非农户口类型
        registerMap.put("hksf",params.get("hksf"));//户口省份
        registerMap.put("hkqx",params.get("hkqx"));//户口区县
        registerMap.put("hkrod",params.get("hkrod"));//户口路
        registerMap.put("hkz",params.get("hkz"));//户口所在的弄（组）
        registerMap.put("HKLDH",params.get("hkldh"));//户口所在的楼栋号
        registerMap.put("hks",params.get("hks"));//户口所在的室
        registerMap.put("hkjz",params.get("hkjz"));//户口街镇
        registerMap.put("hkjwh",params.get("hkjwh"));//户口居委/村
        String hjdjr = (String)params.get("hjdjr");
        if(!BaseChecks.hasEmptyStr(hjdjr)) {
            if(hjdjr.contains("-")) {
                hjdjr = hjdjr.replace("-","");
            }
        }
        registerMap.put("hjdjr",hjdjr);//户籍登记日
        registerMap.put("hzgx",params.get("hzgx"));//与户主关系
        registerMap.put("sfrhyz",params.get("sfrhyz"));//是否人户一致
        registerMap.put("xzzsf",params.get("xzzsf"));//现住址省市
        registerMap.put("xzzqx",params.get("xzzqx"));//现住址区县
        registerMap.put("xzzrod",params.get("xzzrod"));//现居住路
        registerMap.put("xzzz",params.get("xzzz"));//现住址所在的弄（组）
        registerMap.put("xzzldh",params.get("xzzldh"));//现住址楼栋号
        registerMap.put("xzzs",params.get("xzzs"));//现住址室
        registerMap.put("xzzjd",params.get("xzzjd"));//现住址所属街道
        registerMap.put("xzzjw",params.get("xzzjw"));//现住址所属居委
        registerMap.put("xzzyzbm",params.get("xzzyzbm"));//现住址邮编
        registerMap.put("lxdh",params.get("lxdh"));//联系电话
        registerMap.put("txdz",params.get("txdz"));//通信地址
        registerMap.put("txdzyzbm",params.get("txdzyzbm"));//通信地址邮编
        registerMap.put("zfxz",params.get("zfxz"));//住房性质
        registerMap.put("czbh",params.get("czbh"));//(产权房)产证编号
        String djrq = (String)params.get("djrq");
        if(!BaseChecks.hasEmptyStr(djrq)) {
            if(djrq.contains("-")) {
                djrq = djrq.replace("-","");
            }
        }
        registerMap.put("djrq",djrq);//(产权房)登记日期
        registerMap.put("cqfdz",params.get("cqfdz"));//(产权房)地址
        registerMap.put("htbh",params.get("htbh"));//(租赁)合同编号
        String qzrq = (String)params.get("qzrq");
        if(!BaseChecks.hasEmptyStr(qzrq)) {
            if(qzrq.contains("-")) {
                qzrq = qzrq.replace("-","");
            }
        }
        registerMap.put("qzrq",qzrq);//(租赁)起租日期
        registerMap.put("zfqt",params.get("zfqt"));//住房其他
        registerMap.put("gfrgx",params.get("gfrgx"));//与购房人关系
        registerMap.put("sffhjs",params.get("sffhjs"));//是否符合计划生育政策
        registerMap.put("sfnmgtzzn",params.get("sfnmgtzzn"));//是否农民工同住子女
        registerMap.put("sflqcjz",params.get("sflqcjz"));//是否领取残疾证
        registerMap.put("cjlb",params.get("cjlb"));//残疾类别
        registerMap.put("cjzbh",params.get("cjzbh"));//残疾证编号
        String cjzfzrq = (String)params.get("cjzfzrq");
        if(!BaseChecks.hasEmptyStr(cjzfzrq)) {
            if(cjzfzrq.contains("-")) {
                cjzfzrq = cjzfzrq.replace("-","");
            }
        }
        registerMap.put("cjzfzrq",cjzfzrq);//残疾证发证日期
        registerMap.put("cjzfzjg",params.get("cjzfzjg"));//残疾证发证机关
        registerMap.put("adduserid",loginInfo.getId());//添加人id，用户id
        registerMap.put("addtime", Format.getDateTime());//添加时间\
        registerMap.put("deleted","0");//删除位
        registerMap.put("djxx",params.get("djxx"));//登记学校，学校代码
        registerMap.put("njdm",params.get("njdm"));//登记年级代码
        registerMap.put("lqzt","0");//录取状态 默认：0待录取1学校录取2待统筹3区县统筹录取
        registerMap.put("JHRXM",params.get("jhrxm"));//监护人姓名
        registerMap.put("jhrxb",params.get("jhrxb"));//监护人性别
        registerMap.put("jhrgx",params.get("jhrgx"));//与监护人关系
        registerMap.put("jhrdh",params.get("jhrdh"));//监护人电话
        registerMap.put("jhrzjlx",params.get("jhrzjlx"));//监护人证件类型
        registerMap.put("jhrzjhm",params.get("jhrzjhm"));//监护人证件号码
        registerMap.put("jhrhksf",params.get("jhrhksf"));//监护人户口省市
        registerMap.put("jhrqx",params.get("jhrqx"));//监护人户口区县
        registerMap.put("jhrxl",params.get("jhrxl"));//监护人学历
        registerMap.put("jhrgzdw",params.get("jhrgzdw"));//监护人工作单位
        registerMap.put("jhrjzzlx",params.get("jhrjzzlx"));//监护人居住证类型
        registerMap.put("jhrjzzhm",params.get("jhrjzzhm"));//监护人居住证号码
        String jhrjzzyxq = (String)params.get("jhrjzzyxq");
        if(!BaseChecks.hasEmptyStr(jhrjzzyxq)) {
            if(jhrjzzyxq.contains("-")) {
                jhrjzzyxq = jhrjzzyxq.replace("-","");
            }
        }
        registerMap.put("jhrjzzyxq",jhrjzzyxq);//监护人居住证有效期
        registerMap.put("jhrsfbzf",params.get("jhrsfbzf"));//监护人是否标准分
        String jhrlssj = (String)params.get("jhrlssj");
        if(!BaseChecks.hasEmptyStr(jhrlssj)) {
            if(jhrlssj.contains("-")) {
                jhrlssj = jhrlssj.replace("-","");
            }
        }
        registerMap.put("jhrlssj",jhrlssj);//监护人临时居住证办证时间
        registerMap.put("JHRSFLHJY",params.get("jhrsflhjy"));//监护人是否灵活就业
        registerMap.put("JHRLHJYBH",params.get("jhrlhjybh"));//监护人灵活就业证编
        registerMap.put("JHRSYHYLB",params.get("jhrsyhylb"));//监护人就业行业类别
        registerMap.put("jydjcs",params.get("jydjcs"));//监护人就业登记次数
        registerMap.put("ryyj",params.get("ryyj"));//入园依据
        registerMap.put("ryyjlb",params.get("ryyjlb"));//入园依据类别
        registerMap.put("syqk",params.get("syqk"));//生源情况
        return registerMap;
    }

    @Override
    public JSONObject batchImportRegister(Map<String, Object> params) throws SQLException, IOException, BaseException, ParseException {
        //首先校验是否在时间范围内.
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        Map<String,Object> errorMap = new HashMap<>();
        params.put("opentype","1");//登记
        if(!"2".equals(loginInfo.getRoletype())) {
            if(commonService.checkDate(params)){
                JSONObject rs = ResponseUtils.createErrorResponseBody("不在登记时间范围内");
                return  rs;
            }
        }
        //拼接excel表头
        //学校代码	年级	姓名	性别	出生日期	证件类型	身份证件号	港澳通行证号	民族	国籍	是否符合计划生育政策	健康状况	居住证类型	居住证号码	监护人姓名	监护人性别	家庭关系	联系电话	监护人身份证件类型	监护人身份证件号码
        String title = "{DJXX:学校代码,NJDM:年级,XM:姓名,XB:性别,CSRQ:出生日期,SFZLX:证件类型,sfzjh:证件号码,GATXZ:港澳通行证号,MZ:民族,GJDQ:国籍,SFFHJS:是否符合计划生育政策,JKZK:健康状况,JHRXM:监护人姓名,JHRXB:监护人性别,JHRGX:家庭关系,JHRDH:联系电话,JHRZJLX:监护人身份证件类型,JHRZJHM:监护人身份证件号码}";
        params.put("title",title);

        List<Map<String, Object>> registerList = getImportRegisterList(params);
        List<Map<String,Object>> errorList = new ArrayList<>();
        List<Map<String,Object>> successList = new ArrayList<>();
        //不在时间范围段内就直接返回出去

        for(Map<String,Object> entity : registerList) {
            Map<String,Object> register = new HashMap<>();
            register.putAll(entity);
            Map<String,Object> registerMap = transformationRegister(entity);//数据转换
            String checkRegister = (String) registerMap.remove("checkregister");
            if(checkRegister.contains("__")) {
                register.put("remark",checkRegister);
                errorList.add(register);
                continue;
            }
            registerMap.put("userinfo",loginInfo);
            String check =  ruleValidationService.checkImportRegisterJs(registerMap);//数据校验
            if(check.contains("__")) {
                register.put("remark",check);
                errorList.add(register);
                continue;
            }
            //校验通过的，需要进行新增
            successList.add(registerMap);
            //校验通过进行新增
            registerMap.put("id",UUID.randomUUID().toString());
            registerMap.put("addtime",Format.getDateTime());
            registerMap.put("adduserid",loginInfo.getId());
            registerMap.put("userinfo",loginInfo);
            registerMap.put("deleted","0");
            registerMap.put("lqzt","0");//录取状态默认为未录取
            registerMap.put("checkstatus","0");//校验状态默认是未校验
            registerMap.put("djqx",loginInfo.getDistrictcode());//登记区县
            //登记类型
            String djlx = "1";
            //区管市级管理员是没有学校代码
            if(null==loginInfo.getSchoolcode()) {
                djlx="2";
            }
            registerMap.put("djlx",djlx);//登记类型
            String gatxz = (String) registerMap.remove("gatxz");
            String zjlx  = (String) registerMap.get("sfzlx");
            if("6".equals(zjlx)||"7".equals(zjlx)) {
                registerMap.put("sfzjh",gatxz);
            }
            registerMap = CollectionUtils.removeEmptyKeyByParams(registerMap);
            insertRegister(registerMap);
        }
        //写入错误数据
        String errorTitle = "{DJXX:学校代码,NJDM:年级,XM:姓名,XB:性别,CSRQ:出生日期,SFZLX:证件类型,sfzjh:身份证件号,GATXZ:港澳通行证号,MZ:民族,GJDQ:国籍,SFFHJS:是否符合计划生育政策,JKZK:健康状况,JHRXM:监护人姓名,JHRXB:监护人性别,JHRGX:家庭关系,JHRDH:联系电话,JHRZJLX:监护人身份证件类型,JHRZJHM:监护人身份证件号码,REMARK:备注}";
        Map<String, Object> data = new HashMap<>();
        data.put("url1",getExportUrl(title, successList,"新生登记-批量导入成功"));//成功的url
        data.put("url2",getExportUrl(errorTitle, errorList,"新生登记-批量导入失败"));//失败的url
//        data.put("message","导入成功"+successList.size()+"条,失败了"+errorList.size()+"条");
        Integer errorCount = errorList.size();
        Integer successCount = successList.size();
        JSONObject rs = ResponseUtils.createSuccessResponseBody("共"+(successCount+errorCount)+"条数据,执行成功"+successCount+"条,失败了"+errorCount+"条", data);
        return rs;
    }

    /**
     * 获取导出的url
     * @param title
     * @param data
     * @return
     * @throws FileTypeNotFoundException
     * @throws IOException
     */
    private String getExportUrl (String title,List<Map<String,Object>> data,String name) throws FileTypeNotFoundException, IOException {
        //转换为中文输出
//        FileInfoPo fileInfoPo = FileIOComponent.createTempFilePathByType(FileIOComponent.EXPORT_TYPE,"xlsx");
        FileInfoPo fileInfoPo = FileIOComponent.createTempFilePathByType(FileIOComponent.EXPORT_TYPE, "xlsx", name);
        String absPath = fileInfoPo.getFileAbsPath();
        ExportExcel eh = ExportExcel.createExportExcel(absPath, title);
        //写入excel数据
        eh.setCurrentData(data);
        eh.writeCurrentData();
        return fileInfoPo.getFileVirPath();
    }

    /**
     * 导入转换数据是否出现问题
     * @param register
     * @return
     */
    private Map<String,Object> transformationRegister(Map<String,Object> register) {
        StringBuffer str = new StringBuffer();
        str.append(register.get("xm"));
        String njdm = ((String) register.get("njdm"));
        if(BaseChecks.hasEmptyStr(njdm)) {
            str.append("__请填写年级");
        }
        if(!BaseChecks.hasEmptyStr(njdm)) {
            //年级
            try {
                String nj =  DataDict.getCodeByChineseValue(EStandTables.年级表,njdm.trim() );
                register.put("njdm",nj);
            } catch (DictIsNotFoundException e) {
                e.printStackTrace();
                str.append("__年级不符合标准值");
            }
        }

        String xbm = ((String) register.get("xb"));
        if(BaseChecks.hasEmptyStr(xbm)) {
            str.append("__请填写性别");
        }
        if(!BaseChecks.hasEmptyStr(xbm)) {
            //性别转换，
            try {
                String xb =DataDict.getCodeByChineseValue(EStandTables.性别表, xbm.trim());
                register.put("xb",xb);
            } catch (DictIsNotFoundException e) {
                str.append("__性别不符合标准值");
            }
        }

        //证件类型
        String sfzjlx = ((String) register.get("sfzlx"));
        if(BaseChecks.hasEmptyStr(sfzjlx)) {
            str.append("__请填写证件类型");
        }
        if(!BaseChecks.hasEmptyStr(sfzjlx)) {
            try {
                sfzjlx =DataDict.getCodeByChineseValue(EStandTables.证件类型表, sfzjlx);
                register.put("sfzlx",sfzjlx);
            } catch (DictIsNotFoundException e) {
                str.append("__证件类型不符合标准值");
            }

            //当为居民身份证时候转换！
            if("1".equals(sfzjlx)) {
                String sffh  = ((String) register.get("sffhjs"));
                if(BaseChecks.hasEmptyStr(sffh)) {
                    str.append("__请填写是否符合计划生育政策");
                }
                if(!BaseChecks.hasEmptyStr(sffh)) {
                    //是否符合计划生育政策
                    try {
                        String sffhjs =DataDict.getCodeByChineseValue(EStandTables.是否标志表, sffh.trim());
                        register.put("sffhjs",sffhjs);
                    } catch (DictIsNotFoundException e) {
                        str.append("__是否符合计划生育政策不符合标准值");
                    }
                }
                String mz = (String) register.get("mz");
                if(BaseChecks.hasEmptyStr(mz)) {
                    str.append("__请填写民族");
                }
                //名族转换
                try {
                    if(!BaseChecks.hasEmptyStr(mz)) {
                        String mzzw =DataDict.getCodeByChineseValue(EStandTables.民族表, mz);
                        register.put("mz",mzzw);
                    }
                } catch (DictIsNotFoundException e) {
                    str.append("__民族不符合标准值");
                }
            }
        }
        String jkzkm = ((String) register.get("jkzk"));
        if(BaseChecks.hasEmptyStr(jkzkm)) {
            str.append("__请填健康状况");
        }
        if(!BaseChecks.hasEmptyStr(jkzkm)) {
            //健康状况
            try {
                String jkzk =DataDict.getCodeByChineseValue(EStandTables.健康状况表, jkzkm.trim());
                register.put("jkzk",jkzk);
            } catch (DictIsNotFoundException e) {
                str.append("__健康状况不符合标准值");
            }
        }
        String gjm = ((String) register.get("gjdq"));
        if(BaseChecks.hasEmptyStr(gjm)) {
            str.append("__请填写国籍");
        }
        if(!BaseChecks.hasEmptyStr(gjm)) {
            //国籍
            try {
                String gj =DataDict.getCodeByChineseValue(EStandTables.国籍地区表, gjm.trim());
                register.put("gjdq",gj);
            } catch (DictIsNotFoundException e) {
                str.append("__国籍不符合标准值");
            }
        }
        String jhrxbm =  ((String) register.get("jhrxb"));
        if(BaseChecks.hasEmptyStr(jhrxbm)) {
            str.append("__请填写监护人性别");
        }
        if(!BaseChecks.hasEmptyStr(jhrxbm)) {
            //监护人性别
            try {
                String jhrxb =DataDict.getCodeByChineseValue(EStandTables.性别表, jhrxbm.trim());
                register.put("jhrxb",jhrxb);
            } catch (DictIsNotFoundException e) {
                str.append("__监护人性别不符合标准值");
            }
        }
        String jhrgxm  = ((String) register.get("jhrgx"));
        if(BaseChecks.hasEmptyStr(jhrgxm)) {
            str.append("__请填写家庭关系");
        }
        if(!BaseChecks.hasEmptyStr(jhrgxm)) {
            //JHRGX 与监护人关系
            try {
                String jhrgx =DataDict.getCodeByChineseValue(EStandTables.家庭关系表, jhrgxm.trim());
                register.put("jhrgx",jhrgx);
            } catch (DictIsNotFoundException e) {
                str.append("__监护人关系不符合标准值");
            }
        }
        String jhrzjlxm = ((String) register.get("jhrzjlx"));
        if(BaseChecks.hasEmptyStr(jhrzjlxm)) {
            str.append("__请填写监护人证件类型");
        }
        if(!BaseChecks.hasEmptyStr(jhrzjlxm)) {
            //jhrzjlx 监护人证件类型
            try {
                String jhrzjlx =DataDict.getCodeByChineseValue(EStandTables.证件类型表, jhrzjlxm.trim());
                register.put("jhrzjlx",jhrzjlx);
            } catch (DictIsNotFoundException e) {
                str.append("__监护人证件类型");
            }
        }
        register.put("checkRegister",str.toString());
        return register;
    }

    /**
     * 校验导入的数据
     * @param registerStudent
     * @return
     * @throws SQLException
//     */
//    private String checkImportRegister(Map<String,Object> registerStudent) throws SQLException {
//        LoginInfo loginInfo = (LoginInfo) registerStudent.get("userinfo");
//        StringBuffer sb = new StringBuffer();
//        String sfzjlx = (String) registerStudent.get("sfzlx");
//        String xm = (String) registerStudent.get("xm");
//        sb.append(xm);
//        String djxx = (String) registerStudent.get("djxx");
//        //【学校代码】：1、必填。2、只允许输入10位学校代码。
//        if(BaseChecks.hasEmptyStr(djxx)) {
//            sb.append("__请填写学校代码");
//        }
//        if(!BaseChecks.hasEmptyStr(djxx)) {
//            if(!djxx.matches("[0-9]{10}")) {
//                sb.append("__请填写10位数字的学校代码");
//            }
//            //校验是否学校代码存在？
//            if(!checkSchool(djxx,loginInfo)) {
//                sb.append("__学校代码不存在，请重新填写学校代码");
//            }
//            //区管校验区是否一致
//            String roleType = loginInfo.getRoletype();
//            if("2".equals(roleType)) {
//                String qxdm = loginInfo.getDistrictcode();
//                String xxqxdm = djxx.substring(0,6);
//                if(!qxdm.equals(xxqxdm)) {
//                    sb.append("__区县不匹配不能进行登记");
//                }
//            }
//            if("3".equals(roleType)) {
//                String schoolcode = loginInfo.getSchoolcode();
//                if(!schoolcode.equals(djxx)) {
//                    sb.append("__学校不匹配不能进行登记");
//                }
//            }
//        }
//        //【年级】：1、必填。2、只允许选择输入“托班”、“小班”。
//        String nj = (String) registerStudent.get("njdm");
//        if(BaseChecks.hasEmptyStr(nj)) {
//            sb.append("__请填写登记年级");
//        }
//        if(!BaseChecks.hasEmptyStr(nj)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.年级表,nj);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__年级不符合标准表");
//            }
//        }
//        //【证件类型】：1、必填。2、多选一：居民身份证、香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照、其他。
//        if(BaseChecks.hasEmptyStr(sfzjlx)) {
//            sb.append("__请填写证件类型");
//        }
//        if(!BaseChecks.hasEmptyStr(sfzjlx)) {
//            //证件类型表
//            try {
//                DataDict.getChineseValueByCode(EStandTables.证件类型表,sfzjlx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__证件类型不符合标准表");
//            }
//        }
//        /**
//         【姓名】：1、必填。2、【证件类型】为“护照”和“境外永久居住证”时，不允许汉字；3、允许输入汉字时，不允许存在空格。
//         */
//        if(BaseChecks.hasEmptyStr(xm)) {
//            sb.append("__姓名不能为空");
//        }
//        if(!BaseChecks.hasEmptyStr(xm)) {
//            //姓名校验
//            if("1".equals(sfzjlx)||"6".equals(sfzjlx)||"7".equals(sfzjlx)||"8".equals(sfzjlx)||"Z".equals(sfzjlx)) {
//                if(" ".contains(xm)) {
//                    sb.append("__姓名不能有空格");
//                }
//                if (!xm.matches("[\\u4e00-\\u9fa5.·]*")) {
//                    sb.append("__姓名必须为中文、“·”");
//                }
//            }
//            if("A".equals(sfzjlx)||"9".equals(sfzjlx)) {
//                if(" ".equals(xm.substring(0,1))){
//                    sb.append("__姓名首位不能为空格、");
//                }
//                if (!xm.matches("^[A-Za-z\\s,.、-]*$")) {
//                    sb.append("__姓名必须为英文、英文空格、“-”、“.”、“,”");
//                }
//            }
//        }
//        //【性别】：1、必填。2、只允许选择输入“男”、“女”。
//        String xb = (String) registerStudent.get("xb");
//        if(BaseChecks.hasEmptyStr(xb)) {
//            sb.append("__性别不能为空");
//        }
//        if(!BaseChecks.hasEmptyStr(xb)) {
//            //性别
//            try {
//                DataDict.getChineseValueByCode(EStandTables.性别表,xb);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__性别不符合标准表");
//            }
//        }
//        //证件号码
//        //1.不能为空
//        String sfzjh = (String) registerStudent.get("sfzjh");
//        if(!"Z".equals(sfzjlx)) {
//            if(BaseChecks.hasEmptyStr(sfzjh)) {
//                sb.append("__证件号码不能为空");
//            }
//        }
//        String districtCode = loginInfo.getDistrictcode();//后三位
//        districtCode = districtCode.substring(districtCode.length()-3,districtCode.length());
//        String csrq = (String) registerStudent.get("csrq");
//        if(!BaseChecks.hasEmptyStr(csrq)) {
//            if(csrq.contains("-")) {
//                csrq = csrq.replace("-","");
//            }
//        }
//        //1、8位数字，如20120101        2、居民身份证类型时：与证件号码中的出生日期匹配。        3、证件类型“其他”：与证件号码中的出生日期匹配。
//        if(BaseChecks.hasEmptyStr(csrq)) {
//            sb.append("__请填写出生日期");
//        }
//        if(!BaseChecks.hasEmptyStr(csrq)) {
//            if(!csrq.matches("\\d{8}")) {
//                sb.append("__请填写正确的出生日期格式");
//            }
//        }
//        /**
//         【证件号码】：
//         1、不允许有中文字符
//         2、居民身份证类型时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
//         3、居民身份证类型时：与学生的【性别】比较是否一致
//         4、居民身份证类型时：长度满足18位
//         5、不允许重复
//         6、【证件类型】为“其他”时，不需填写（系统根据《上海市中小学学生学籍号编制规则》自动生成临号）
//         7、必填
//         8、存在英文字母时，需大写。
//         */
//        //证件类型为其他的时候
//        if("Z".equals(sfzjlx)) {
//            //当证件号码不为空的时候校验，
//            if(!BaseChecks.hasEmptyStr(sfzjh)){
//                //生成临时身份证 4位数流水
//                //校验是否符合规范
//                String ls = sfzjh.substring(0,2);
//                if(!"LS".equals(ls)) {
//                    sb.append("__临时证件号码必须为LS开头");
//                }
//                String qx = sfzjh.substring(2,5);
//
//                if(!districtCode.equals(qx)) {
//                    sb.append("__临时证件号码区县不匹配");
//                }
//                String scsrq = sfzjh.substring(5,13);
//                if(!csrq.equals(scsrq)) {
//                    sb.append("__临时证件号码出生日期不匹配");
//                }
//                String cxb = sfzjh.substring(13,14);
//                if(!xb.equals(cxb)) {
//                    sb.append("__临时证件号码性别不匹配");
//                }
//            }
//            if(BaseChecks.hasEmptyStr(sfzjh)){
//                //生成临时身份证 4位数流水
//                sfzjh = "LS"+districtCode+csrq+xb+(new Random()).nextInt(9999);
//                //校验重复 重复重新生成个
//                Map<String,Object> registerMap = new HashMap<>();
//                registerMap.put("sfzjh",sfzjh);
//                registerMap.put("userinfo",loginInfo);
//                registerMap.put("id",registerMap.get("id"));
//                if(checkRegisterStudentSfzjh(registerMap)){
//                    sfzjh = "LS"+districtCode+csrq+xb+(new Random()).nextInt(9999);
//                }
//            }
//
//        }
//
//        //当证件号码不为空的时候
//        if(!BaseChecks.hasEmptyStr(sfzjh)){
//            //当为居民身份证需要校验
//            /**
//             2、居民身份证类型时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
//             3、居民身份证类型时：与学生的【性别】比较是否一致
//             4、居民身份证类型时：长度满足18位
//             5、不允许重复
//             */
//            if("1".equals(sfzjlx)) {
//                if(18!=sfzjh.length()) {
//                    sb.append("__证件类型为居民身份证，需要填写18位");
//                }
//                if(!isCardId(sfzjh)) {
//                    sb.append("__身份证填写错误");
//                }
//                if(BaseChecks.isChineseChar(sfzjh)) {
//                    sb.append("__身份证不允许有中文字符");
//                }
//                String sfzxb = sfzjh.substring(sfzjh.length()-2,sfzjh.length()-1);
//                Integer intXb = Integer.parseInt(sfzxb);
//                //除不尽就是男   性别字段 xb：1是男，2是女
//                if (0==(intXb%2)) {
//                    if ("1".equals(xb)) {
//                        sb.append("__身份证和性别不匹配");
//                    }
//                } else {
//                    if ("2".equals(xb)) {
//                        sb.append("__身份证和性别不匹配");
//                    }
//                }
//                //出生日期
//                String scsrq = sfzjh.substring(6,14);
//                if(!scsrq.equals(csrq)) {
//                    sb.append("__身份证和出生日期不匹配");
//                }
//                //【民族】：1、【证件类型】为“居民身份证”时填写。   2、按《民族代码表》填写。如汉族、回族等。
//                String mz = (String) registerStudent.get("mz");
//                if(BaseChecks.hasEmptyStr(mz)){
//                    sb.append("__当证件类型为居民身份证，需要填写民族");
//                }
//                if(!BaseChecks.hasEmptyStr(mz)){
//                    try {
//                        DataDict.getChineseValueByCode(EStandTables.民族表,mz );
//                    } catch (DictIsNotFoundException e) {
//                        sb.append("__民族不符合标准表");
//                    }
//                }
//                //【是否符合计划生育政策】1、【证件类型】为“居民身份证”时填写。2、只填写是、否。
//                String sffhjs = (String) registerStudent.get("sffhjs");
//                if(BaseChecks.hasEmptyStr(sffhjs)){
//                    sb.append("__当证件类型为居民身份证，请选择是否符合计划生育政策");
//                }
//                if(!BaseChecks.hasEmptyStr(sffhjs)){
//                    try {
//                        DataDict.getChineseValueByCode(EStandTables.是否标志表,sffhjs );
//                    } catch (DictIsNotFoundException e) {
//                        sb.append("__是否符合计划生育政策不符合标准表");
//                    }
//                }
//            }
//            //校验重复
//            Map<String,Object> registerMap = new HashMap<>();
//            registerMap.put("sfzjh",sfzjh);
//            registerMap.put("userinfo",loginInfo);
//            registerMap.put("id",registerStudent.get("id"));
//            //删除
//            if(checkRegisterStudentSfzjh(registerMap)){
//                sb.append("__证件号码重复");
//            }
//        }
//        //香港和澳门证件类型的时候需要校验，港澳台证件号码
//        if("6".equals(sfzjlx)||"7".equals(sfzjlx)) {
//            String gatxz = (String) registerStudent.get("gatxz");
//            //如果港澳通行证为空，去获取证件号码
//            if(BaseChecks.hasEmptyStr(gatxz)) {
//                gatxz= sfzjh;
//            }
//            if(!BaseChecks.hasEmptyStr(gatxz)) {
//                if(BaseChecks.isChineseChar(gatxz)) {
//                    sb.append("__港澳通行证号不允许有中文字符");
//                }
//                if(!gatxz.matches("^[A-Z0-9]+$")) {
//                    sb.append("__港澳通行证号,只允许输入英文字符和数字，其中英文字母需大写。");
//                }
//                if(" ".equals(gatxz.substring(0,1))){
//                    sb.append("__澳通行证号,首位不能为空格、");
//                }
//            }
//        }
//        String gj = (String) registerStudent.get("gjdq");
//        //国籍必填
//        if(BaseChecks.hasEmptyStr(gj)) {
//            sb.append("__请填写国籍");
//        }
//        if(!BaseChecks.hasEmptyStr(gj)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.国籍地区表, gj);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__国籍不符合标准表");
//            }
//            /**
//             156	中国
//             344	中国香港
//             446	中国澳门
//             158	中国台湾
//             1	居民身份证
//             6	香港特区身份证明
//             7	澳门特区身份证明
//             8	台湾居民来往大陆通行证
//             C	其他
//             3、【证件类型】为“香港特区身份证明”的，国籍必须选择为“中国香港”。
//             4、【证件类型】为“澳门特区身份证明”的，国籍必须选择为“中国澳门”。
//             5、【证件类型】为“台湾居民来往大陆通行证”的，国籍必须选择为“中国台湾”。
//             6、【证件类型】为“居民身份证”或“其他”的，国籍必须选择为“中国”。
//             7、【证件类型】为“护照”或“境外永久居住证”的，国籍不能选择为“中国”、“中国香港”、“中国澳门”、“中国台湾”。
//             */
//            if("6".equals(sfzjlx)&&!"344".equals(gj)) {
//                sb.append("__【证件类型】为“香港特区身份证明”的，国籍必须选择为“中国香港”。");
//            }
//            if("7".equals(sfzjlx)&&!"446".equals(gj)) {
//                sb.append("__【证件类型】为“澳门特区身份证明”的，国籍必须选择为“中国澳门”。");
//            }
//            if("8".equals(sfzjlx)&&!"158".equals(gj)) {
//                sb.append("__【证件类型】为“台湾居民来往大陆通行证”的，国籍必须选择为“中国台湾”");
//            }
//            if(("1".equals(sfzjlx)||"Z".equals(sfzjlx))&&!"156".equals(gj)) {
//                sb.append("__【证件类型】为“居民身份证”或“其他”的，国籍必须选择为“中国”。");
//            }
//            if(("9".equals(sfzjlx)||"A".equals(sfzjlx)) &&
//                    ("344".equals(gj)||"446".equals(gj)||"158".equals(gj)||"156".equals(gj)) ) {
//                sb.append("__【证件类型】为“护照”或“境外永久居住证”的，国籍不能选择为“中国”、“中国香港”、“中国澳门”、“中国台湾”。");
//            }
//        }
//        String jkzk = (String) registerStudent.get("jkzk");
//        //【健康状况】1、必填。     2、多选一：健康或良好,一般或较弱,有慢性病,残疾。
//        if(BaseChecks.hasEmptyStr(jkzk)) {
//            sb.append("__请填写健康状况");
//        }
//        if(!BaseChecks.hasEmptyStr(jkzk)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.健康状况表, jkzk);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__健康状况不符合标准表");
//            }
//        }
//        //【监护人姓名】：必填
//        String jhrxm = (String) registerStudent.get("jhrxm");
//        if(BaseChecks.hasEmptyStr(jhrxm)) {
//            sb.append("__监护人姓名不能为空");
//        }
//        //jhrzjlx 监护人证件类型 【监护人证件类型】        1、必填。 2、多选一：居民身份证、香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照、其他。
//        String jhrzjlx = ((String) registerStudent.get("jhrzjlx"));
//        if(BaseChecks.hasEmptyStr(jhrzjlx)) {
//            sb.append("__监护人证件类型不能为空");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrzjlx)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.证件类型表, jhrzjlx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__监护人证件类型不符合标准值");
//            }
//            if(!BaseChecks.hasEmptyStr(jhrxm)) {
//                //姓名校验
//                if("1".equals(jhrzjlx)||"6".equals(jhrzjlx)||"7".equals(jhrzjlx)||"8".equals(jhrzjlx)||"Z".equals(jhrzjlx)) {
//                    if(" ".contains(jhrxm)) {
//                        sb.append("__监护人姓名不能有空格");
//                    }
//                    if (!jhrxm.matches("[\\u4e00-\\u9fa5.·]*")) {
//                        sb.append("__监护人姓名必须为中文、“·”");
//                    }
//                }
//                if("A".equals(jhrzjlx)||"9".equals(jhrzjlx)) {
//                    if(" ".equals(jhrxm.substring(0,1))){
//                        sb.append("__监护人姓名首位不能为空格、");
//                    }
//                    if (!jhrxm.matches("^[A-Za-z\\s,.、-]*$")) {
//                        sb.append("__监护人姓名必须为英文、英文空格、“-”、“.”、“,”");
//                    }
//                }
//            }
//        }
//        //【监护人性别】：1、必填。2、只允许选择输入“男”、“女”。
//        String jhrxb = (String) registerStudent.get("jhrxb");
//        if(BaseChecks.hasEmptyStr(jhrxb)) {
//            sb.append("__监护人性别不能为空");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrxb)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.性别表, jhrxb);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__性别不符合标准表");
//            }
//        }
//        //监护人家庭关系 【家庭关系】：1、必填。2、多选一：父亲,母亲,祖父母/外祖父母,兄弟姐妹,其他亲属,非亲属。
//        String jhrgx = (String) registerStudent.get("jhrgx");
//        if(BaseChecks.hasEmptyStr(jhrgx)) {
//            sb.append("__家庭关系不能为空");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrgx)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.家庭关系表, jhrgx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__家庭关系不符合标准值");
//            }
//        }
//        /**
//        【监护人身份证号码】
//         1、不允许有中文字符
//         2、家长【身份证件类型】为“居民身份证”时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
//         3、家长【身份证件类型】为“居民身份证”时：与学生的【性别】比较是否一致
//         4、家长【身份证件类型】为“居民身份证”时：长度满足18位
//         5、不允许重复
//         6、必填，但家庭成员【身份证件类型】为“其他”时不填。
//         7、存在英文字母时，需大写。
//         */
//        String jhrzjhm = ((String) registerStudent.get("jhrzjhm"));
//        if(BaseChecks.hasEmptyStr(jhrzjhm)) {
//            sb.append("__监护人证件号码请填写");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrzjhm) && !BaseChecks.hasEmptyStr(jhrzjlx)) {
//            if("1".equals(jhrzjlx)) {
//                if(18!=jhrzjhm.length()) {
//                    sb.append("__监护人证件类型为居民身份证，需要填写18位");
//                }
//                if(!isCardId(jhrzjhm)) {
//                    sb.append("__监护人身份证填写错误");
//                }
//                if(BaseChecks.isChineseChar(jhrzjhm)) {
//                    sb.append("__监护人身份证不允许有中文字符");
//                }
//                if(jhrzjhm.contains("X")) {
//                    //走正则
//                    if(!jhrzjhm.matches("[0-9]{17}X")) {
//                        sb.append("__为“居民身份证”时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。");
//                    }
//                }
//                String jhrzjhmxb = jhrzjhm.substring(jhrzjhm.length()-2,jhrzjhm.length()-1);
//                Integer intXb = Integer.parseInt(jhrzjhmxb);
//                //除不尽就是男   性别字段 xb：1是男，2是女
//                if (0==(intXb%2)) {
//                    if ("1".equals(xb)) {
//                        sb.append("__监护人身份证和性别不匹配");
//                    }
//                } else {
//                    if ("2".equals(xb)) {
//                        sb.append("__监护人身份证和性别不匹配");
//                    }
//                }
//            }
//        }
//
//        //【联系电话】：1、必填。2、只允许数字和英文中划线、英文空格。
//        String jhrdh = (String) registerStudent.get("jhrdh");
//        if(BaseChecks.hasEmptyStr(jhrdh)) {
//            sb.append("__请填写监护人联系电话");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrdh)) {
//           //不为空
//            if (!jhrdh.matches("[0-9]{3}[/-]{1}[0-9]{8}||[0-9]{11}"))sb.append("__家庭联系人电话必须为11位数或者为：区号-开头的");
//        }
//        return  sb.toString();
//    }

    /**
     * 校验学校代码是否存在
     * @param schoolCode
     * @param loginInfo
     * @return 默认返回查询不到数据 false ，查询到数据返回true，
     * @throws SQLException
     */
    private Boolean checkSchool(String schoolCode ,LoginInfo loginInfo) throws SQLException {
        QueryParams querySchool  = QueryParams.createQueryParams("vb_querySchool_lrs");
        querySchool.addQueryParams(Parameter.createParameter("schoolcode",schoolCode));
        List<Map<String, Object>> schoolList = baseDaoComponent.selectDataByParams(querySchool);
        if(0<schoolList.size()) {
            return  true;
        }
        return false;
    }

//    private String checkRegisterStudent(Map<String,Object> registerStudent) throws SQLException {
//        StringBuffer sb = new StringBuffer();
//        String sfzjlx = (String) registerStudent.get("sfzlx");
//        String xm = (String) registerStudent.get("xm");
//        sb.append(xm);
//        String hksf = (String) registerStudent.get("hksf");
//        String jzzlx = (String) registerStudent.get("jzzlx");
//        //1、字典
//        // 2、【身份证件类型】为“1居民身份证”时，且【户口省份】不为‘310000上海市’时
//        //3、【身份证件类型】为“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照”时填写。
//        if("1".equals(sfzjlx)&&!"310000".equals(hksf)) {
//            if(BaseChecks.hasEmptyStr(jzzlx)) {
//                sb.append("__居住证类型请选择");
//            }
//        }
//        //当证件类型为：为“6香港特区身份证明、7澳门特区身份证明、8台湾居民来往大陆通行证、9境外永久居住证、A护照”时填写。
//        if("6".equals(sfzjlx)||"7".equals(sfzjlx)
//                    ||"8".equals(sfzjlx)||"9".equals(sfzjlx)||"A".equals(sfzjlx)
//                ||"Z".equals(sfzjlx)) {
//            if(BaseChecks.hasEmptyStr(jzzlx)) {
//                sb.append("__居住证类型请选择");
//            }
//        }
//        //当居住证类型不为空
//        if(!BaseChecks.hasEmptyStr(jzzlx)) {
//            //1、【居住证类型】不为空和“暂无”时             2、只允许填写英文大写字母和数字。
//            String jzzhm = (String) registerStudent.get("jzzhm");
//            if(!"0".equals(jzzlx)) {
//                if(BaseChecks.hasEmptyStr(jzzhm)) {
//                    sb.append("__请填写监护人居住证号码");
//                }
//                String jzzyxq = (String) registerStudent.get("jzzyxq");
//                if(BaseChecks.hasEmptyStr(jzzyxq)) {
//                    sb.append("__请选择居住证有效时间");
//                }
//            }
//            if(!BaseChecks.hasEmptyStr(jzzhm)){
//                //正则校验
//                if(!jzzhm.matches("^[A-Z0-9]+$")){
//                    sb.append("__居住证号码只允许填写英文大写字母和数字。");
//                }
//            }
//        }
//
//        String hkxz = (String) registerStudent.get("hkxz");
//        //字典 【身份证件类型】为1居民身份证时填写
//        if("1".equals(sfzjlx)) {
//            if(BaseChecks.hasEmptyStr(hkxz)) {
//                sb.append("__请选择户口性质");
//            }
//            if(!BaseChecks.hasEmptyStr(hkxz)) {
//                //非农业户口类型 必填
//                try {
//                    DataDict.getChineseValueByCode(EStandTables.户口性质表, hkxz);
//                } catch (DictIsNotFoundException e) {
//                    sb.append("__非农业户口类型不符合标准表");
//                }
//                //【户口性质】为“非农业家庭户口”和“非农业集体户口”时
//                if("1".equals(hkxz) || "3".equals(hkxz)) {
//                    //非农业户口类型 必填
//                    try {
//                        DataDict.getChineseValueByCode(EStandTables.非农业户口类型表, (String) registerStudent.get("fnhklx"));
//                    } catch (DictIsNotFoundException e) {
//                        sb.append("__非农业户口类型不符合标准表");
//                    }
//                }
//            }
//        }
//        /**
//          字典
//         1、当【身份证件类型】为“居民身份证时”时，在“常驻、蓝印、外省市”三个中选一个填写。
//         2、当【身份证件类型】为“其他”时，在“常驻、蓝印”两个中选一个填写。
//         3、当【身份证件类型】为“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证”时，只能选择“港澳台侨”。
//         4、当【身份证件类型】为“境外、护照”时，只能选择“外籍”。
//         */
//        //户籍类别
//        String hjlb = (String) registerStudent.get("hjlb");
//        if(BaseChecks.hasEmptyStr(hjlb)) {
//            sb.append("__户籍类别请选择");
//        }
//        if(!BaseChecks.hasEmptyStr(hjlb)) {
//            //当户籍类别填写
//            //1.【证件类型】为“居民身份证”时，“常驻，蓝印，外省市”中三选一。
//            if("1".equals(sfzjlx)) {
//                if("1".equals(hjlb)||"2".equals(hjlb)||"3".equals(hjlb)) {
//                } else  {
//                    sb.append("__证件类型“居民身份证”时，户籍类别“常驻，蓝印，外省市”中三选一。");
//                }
//            }
//            //2【证件类型】为“其他”时，“常驻、蓝印”二选一。
//            if("Z".equals(sfzjlx)) {
//                if("1".equals(hjlb)||"2".equals(hjlb)) {
//
//                }else {
//                    sb.append("__证件类型为“其他”时，户籍类别“常驻、蓝印”二选一。");
//                }
//            }
//            //3“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证”时，只能选“港澳台侨”
//            if("6".equals(sfzjlx)||"7".equals(sfzjlx)||"8".equals(sfzjlx)) {
//                if(!"4".equals(hjlb)) {
//                    sb.append("__证件类型为香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证”时，只能选“港澳台侨”。");
//                }
//            }
//            //4.【证件类型】为“境外、护照”时，只能选“外籍”。
//            if("9".equals(sfzjlx)||"A".equals(sfzjlx)) {
//                if(!"5".equals(hjlb)) {
//                    sb.append("__证件类型为“境外、护照”时，只能选“外籍”。");
//                }
//            }
//        }
//        //是否人户一致
//        try {
//            DataDict.getChineseValueByCode(EStandTables.是否标志表, (String) registerStudent.get("sfrhyz"));
//        } catch (DictIsNotFoundException e) {
//            sb.append("__是否人户一致不符合标准表");
//        }
//        //当为居民身份证，必填 户籍登记日期
//        if("1".equals(sfzjlx)) {
//            String hjdjr = (String)registerStudent.get("hjdjr");
//            if(!BaseChecks.hasEmptyStr(hjdjr)) {
//                if(hjdjr.contains("-")) {
//                    hjdjr = hjdjr.replace("-","");
//                }
//            }
//            if(!isBirthday(hjdjr)) {
//                sb.append("__户籍登记日期填写不准确");
//            }
//            //户主关系1、字典            2、【身份证件类型】为1居民身份证时
//            String hzgx = (String) registerStudent.get("hzgx");
//            if(BaseChecks.hasEmptyStr(hzgx)) {
//                sb.append("__请选择与户主关系");
//            }
//            if(!BaseChecks.hasEmptyStr(hzgx)) {
//                try {
//                    DataDict.getChineseValueByCode(EStandTables.户主关系表, hzgx);
//                } catch (DictIsNotFoundException e) {
//                    sb.append("__与户主关系不符合标准表");
//                }
//            }
//            /**
//             1、【身份证件类型】为1居民身份证时，必填
//             2、【户籍类别】为“常驻”和“蓝印”时，默认为“上海市”
//             3、字典
//             */
//            if(BaseChecks.hasEmptyStr(hksf)) {
//                sb.append("__请选择户口省份");
//            }
//            //户口省份
//            if(!BaseChecks.hasEmptyStr(hksf)) {
//                try {
//                    DataDict.getChineseValueByCode(EStandTables.省份城市表, hksf);
//                } catch (DictIsNotFoundException e) {
//                    sb.append("__户口省份不符合标准表");
//                }
//                //当为居民身份证时候校验
//                //当省份为：上海市的时候校验。户口街道，户口居委
//                if("310000".equals(hksf)) {
////                    1、【身份证件类型】为1居民身份证时，必填
////                    2、【户籍类别】为“常驻”和“蓝印”时，默认为“上海市”
////                    3、字典
//                    if(!"310100".equals(registerStudent.get("hkcity"))) {
//                        sb.append("__请选择户口市");
//                    }
//                    String hkjz = (String) registerStudent.get("hkjz");//户口街镇
//                    if(BaseChecks.hasEmptyStr(hkjz)) {
//                        sb.append("__户口街镇请选择");
//                    }
//                    if(!BaseChecks.hasEmptyStr(hkjz)) {
//                        try {
//                            DataDict.getChineseValueByCode(EStandTables.街道表, hkjz);
//                        } catch (DictIsNotFoundException e) {
//                            sb.append("__户口街道不符合标准表");
//                        }
//                    }
//                    String hkjwh = (String) registerStudent.get("hkjwh");//居委
//                    if(BaseChecks.hasEmptyStr(hkjwh)) {
//                        sb.append("__户口居委请选择");
//                    }
//                    if(!BaseChecks.hasEmptyStr(hkjwh)) {
//                        try {
//                            DataDict.getChineseValueByCode(EStandTables.居委表, hkjwh);
//                        } catch (DictIsNotFoundException e) {
//                            sb.append("__户口居委不符合标准表");
//                        }
//                    }
//                    String hkrod = (String) registerStudent.get("hkrod");//户口路
//                    if(BaseChecks.hasEmptyStr(hkrod)) {
//                        sb.append("__户口路请填写");
//                    }
//                    String hkz = (String) registerStudent.get("hkz");//户口组
//                    if(BaseChecks.hasEmptyStr(hkz)) {
//                        sb.append("__户口组请填写");
//                    }
//                    String hkldh = (String) registerStudent.get("hkldh");//户口所在的楼栋号
//                    if(BaseChecks.hasEmptyStr(hkldh)) {
//                        sb.append("__户口所在的楼栋号请填写");
//                    }
//                    String hks = (String) registerStudent.get("hks");//户口所在的室
//                    if(BaseChecks.hasEmptyStr(hks)) {
//                        sb.append("__户口所在的室请填写");
//                    }
//                }
////                hkcity 户口市和 wsshkdz 外省市户口地址
//                if(!"310000".equals(hksf)) {
//                    if(BaseChecks.hasEmptyStr((String) registerStudent.get("wsshkdz"))) {
//                        sb.append("__请填写户口详细地址");
//                    }
//                }
//            }
//            //户口区县 1、字典           2、【身份证件类型】为1居民身份证时
//            String hkqx = (String) registerStudent.get("hkqx");
//            if(BaseChecks.hasEmptyStr(hkqx)) {
//                sb.append("__请选择户口区县");
//            }
//            try {
//                DataDict.getChineseValueByCode(EStandTables.省份城市表, hkqx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__户口区县不符合标准表");
//            }
//        }
//        //现在居住地没校验！规则未定义下来 TODO 向立军 2017年3月1日09:36:34
//
//        String xzzsf = (String) registerStudent.get("xzzsf");//现在居住地
//        if(BaseChecks.hasEmptyStr(xzzsf)) {
//            sb.append("__请选择现居住地省份");
//        }
//        if(!BaseChecks.hasEmptyStr(xzzsf)) {
//            if(!"310100".equals(xzzsf)) {
//                sb.append("__现居住地省份必须为上海市");
//            }
//        }
////        xzzqx	现住址区县
//        String xzzqx = (String) registerStudent.get("xzzqx");
//        if(BaseChecks.hasEmptyStr(xzzqx)) {
//            sb.append("__请选择现居住地区县");
//        }
//        if(!BaseChecks.hasEmptyStr(xzzqx)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.区县表, xzzqx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__现居住地区县不符合标准表");
//            }
//        }
//        String xzzjd = (String) registerStudent.get("xzzjd");
//        if(BaseChecks.hasEmptyStr(xzzjd)) {
//            sb.append("__请选择现居住地街道");
//        }
//        if(!BaseChecks.hasEmptyStr(xzzjd)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.街道表, xzzjd);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__现居住地街道不符合标准表");
//            }
//        }
//        String xzzjw = (String) registerStudent.get("xzzjw");
//        if(BaseChecks.hasEmptyStr(xzzjw)) {
//            sb.append("__请选择现居住地居委");
//        }
//        if(!BaseChecks.hasEmptyStr(xzzjw)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.居委表, xzzjw);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__现居住地居委不符合标准表");
//            }
//        }
//        String xzzrod = (String) registerStudent.get("xzzrod");
//        if(BaseChecks.hasEmptyStr(xzzrod)) {
//            sb.append("__请填写现居住地址路");
//        }
//        String xzzz = (String) registerStudent.get("xzzz");
//        if(BaseChecks.hasEmptyStr(xzzz)) {
//            sb.append("__请填写现住址所在的弄（组）");
//        }
//        String xzzldh = (String) registerStudent.get("xzzldh");
//        if(BaseChecks.hasEmptyStr(xzzldh)) {
//            sb.append("__请填写现住址楼栋号");
//        }
//        String xzzs = (String) registerStudent.get("xzzs");
//        if(BaseChecks.hasEmptyStr(xzzs)) {
//            sb.append("__请填写现住址室");
//        }
//        //现居住地邮编 必填 2开头的六位数字.
//        String xzzyzbm = (String) registerStudent.get("xzzyzbm");
//        if(!"2".equals(xzzyzbm.substring(0,1))){
//            sb.append("__邮编首位必须为2开头");
//        }
//        if (!xzzyzbm.matches("[0-9]{6}")) {
//            sb.append("__邮编不符合6位数要求、");
//        }
//        //联系电话 只允许最多11个字符（0 1 2 3 4 5 6 7 8 9 - 的组合），首位只允许数字。
//        String lxdh = (String) registerStudent.get("lxdh");
//        if(BaseChecks.hasEmptyStr(lxdh)) {
//            sb.append("__联系电话不能为空、");
//        }
//        if(!BaseChecks.hasEmptyStr(lxdh)) {
//            if (!lxdh.matches("[0-9]{3}[/-]{1}[0-9]{8}||[0-9]{11}"))sb.append("学生联系电话必须为11位数或者为：区号-开头的");
////            if(11<lxdh.length()) {
////                sb.append("__联系电话只允许最多11个字符");
////            }
////            if (!lxdh.matches("[\\d-]+")) {
////                sb.append("__联系电话必须为数字和-");
////            }
//        }
//        //住房性质
//        String zfxz = (String) registerStudent.get("zfxz");
//        if(BaseChecks.hasEmptyStr(zfxz)) {
//            sb.append("__住房性质必填、");
//        }
//        //产权房
//        if(!BaseChecks.hasEmptyStr(zfxz)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.住房性质表, zfxz);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__住房性质不符合标准表");
//            }
//
//            //【住房性质】为“产权房”时必填 ,【住房性质】为“产权房”时必填
//            if ("4".equals(zfxz)) {
//                if(BaseChecks.hasEmptyStr((String) registerStudent.get("czbh"))) {
//                    sb.append("__住房性质为产权房，产权房产证编号必填、");
//                }
//                String djrq =  (String) registerStudent.get("djrq");
//                if(BaseChecks.hasEmptyStr(djrq)) {
//                    sb.append("__住房性质为产权房，产权房登记日期必填、");
//                }else {
//                    if(isBirthday(djrq)){
//                        sb.append("__产权房登记日期格式不准确,如:20120302、");
//                    }
//                }
//                if(BaseChecks.hasEmptyStr((String) registerStudent.get("cqfdz"))) {
//                    sb.append("__住房性质为产权房，产权房地址必填、");
//                }
//            }
//
//            //【住房性质】为“租赁”时必填 【住房性质】为“租赁”时必填
//            if("1".equals(zfxz)||"3".equals(zfxz)) {
//                if(BaseChecks.hasEmptyStr((String) registerStudent.get("htbh"))) {
//                    sb.append("__【住房性质】为“公/廉租房”和“租赁”时，合同编号必填。、");
//                }
//                if(BaseChecks.hasEmptyStr((String) registerStudent.get("qzrq"))) {
//                    sb.append("__【住房性质】为“公/廉租房”和“租赁”时,起租日期必填。、");
//                }
//            }
//            if("5".equals(zfxz)) {
//                if(BaseChecks.hasEmptyStr((String) registerStudent.get("zfqt"))) {
//                    sb.append("__【住房性质】为其他，请填写住房其他原因");
//                }
//            }
//        }
//         //购房人关系
//        String gfrgx = (String) registerStudent.get("gfrgx");
//        if(BaseChecks.hasEmptyStr(gfrgx)){
//            sb.append("__请选择购房人关系");
//        }
//        if(!BaseChecks.hasEmptyStr(gfrgx)){
//            try {
//                DataDict.getChineseValueByCode(EStandTables.户主关系表, gfrgx);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__购房人关系不符合标准表");
//            }
//        }
//        //是否农民工同住子女	C 		是否项。【身份证件类型】为1居民身份证时
//        if("1".equals(sfzjlx)) {
//            String sfnmgtzzn = (String) registerStudent.get("sfnmgtzzn");
//            if(BaseChecks.hasEmptyStr(sfnmgtzzn)){
//                sb.append("__请选择是否农民工同住子女");
//            }
//            if(!BaseChecks.hasEmptyStr(sfnmgtzzn)){
//                try {
//                    DataDict.getChineseValueByCode(EStandTables.是否标志表, sfnmgtzzn);
//                } catch (DictIsNotFoundException e) {
//                    sb.append("__是否农民工同住子女不符合标准表");
//                }
//            }
//        }
//        String sflqcjz = (String) registerStudent.get("sflqcjz");
//        if(BaseChecks.hasEmptyStr(sflqcjz)){
//            sb.append("__请选择是否领取残疾证");
//        }
//        if(!BaseChecks.hasEmptyStr(sflqcjz)){
//            try {
//                DataDict.getChineseValueByCode(EStandTables.是否标志表, sflqcjz);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__是否领取残疾证不符合标准表");
//            }
//            //当为为残疾幼儿的时候
//            if("1".equals(sflqcjz)) {
//                String cjlb = (String) registerStudent.get("cjlb");
//                if(BaseChecks.hasEmptyStr(cjlb)){
//                    sb.append("__请选择残疾类别");
//                }
//                if(!BaseChecks.hasEmptyStr(cjlb)){
//                    try {
//                        DataDict.getChineseValueByCode(EStandTables.残疾类别表, cjlb);
//                    } catch (DictIsNotFoundException e) {
//                        sb.append("__残疾类别不符合标准表");
//                    }
//                }
//                String cjzbh = (String) registerStudent.get("cjzbh");
//                String cjzfzrq = (String) registerStudent.get("cjzfzrq");
//                String cjzfzjg = (String) registerStudent.get("cjzfzjg");
//                if(BaseChecks.hasEmptyStr(cjzbh)){
//                    sb.append("__请填写残疾证编号");
//                }
//                if(BaseChecks.hasEmptyStr(cjzfzrq)){
//                    sb.append("__请填写残疾证发证日期");
//                }
//                if(BaseChecks.hasEmptyStr(cjzfzjg)){
//                    sb.append("__请填写残疾证发证机关");
//                }
//            }
//        }
//        String ryyj = (String) registerStudent.get("ryyj");
//        if(BaseChecks.hasEmptyStr(ryyj)){
//            sb.append("__请选择入园依据");
//        }
//        if(!BaseChecks.hasEmptyStr(ryyj)){
//            try {
//                DataDict.getChineseValueByCode(EStandTables.入园依据表, ryyj);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__入园依据不符合标准表");
//            }
//        }
//        String ryyjlb = (String) registerStudent.get("ryyjlb");
//        if(BaseChecks.hasEmptyStr(ryyjlb)){
//            sb.append("__请选择入园依据类别");
//        }
//        if(!BaseChecks.hasEmptyStr(ryyjlb)){
//            try {
//                DataDict.getChineseValueByCode(EStandTables.入园依据类别表, ryyjlb);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__入园依据类别不符合标准表");
//            }
//        }
//        //入园依据类别
//        //1.学生【证件类型】为“居民身份证”或“其他”
//        if("1".equals(sfzjlx)||"Z".equals(sfzjlx)) {
//            if(!BaseChecks.hasEmptyStr(ryyj) && !BaseChecks.hasEmptyStr(ryyjlb)){
//                //+【户籍类别】为“常驻”或“蓝印”的， 上海市
//                if("1".equals(hjlb) || "2".equals(hjlb)) {
//                    if("10".equals(ryyj)) {
//                        if("10".equals(ryyjlb) || "11".equals(ryyjlb) || "12".equals(ryyjlb)) {
//                        } else {
//                            sb.append("__入园依据类别请选择，本地段户籍，本区户籍，本市外区县户籍");
//                        }
//                    }
//                    if("50".equals(ryyj)) {
//                        if("50".equals(ryyjlb) || "51".equals(ryyjlb) || "52".equals(ryyjlb)) {
//                        } else {
//                            sb.append("__入园依据类别请选择，本地段户籍，本区户籍，本市外区县户籍");
//                        }
//                    }
//                }
//            }
//        }
//        //外省市
//        if("1".equals(sfzjlx)&&"3".equals(hjlb)) {
//            if("10".equals(ryyj)) {
//                if("13".equals(ryyjlb) || "14".equals(ryyjlb) || "15".equals(ryyjlb)) {
//                } else {
//                    sb.append("__入园依据类别请选择:居住证标准积分,居住证,双证");
//                }
//            }
//            if("50".equals(ryyj)) {
//                if("53".equals(ryyjlb) || "54".equals(ryyjlb) || "55".equals(ryyjlb)) {
//                } else {
//                    sb.append("__入园依据类别请选择:居住证标准积分,居住证,双证");
//                }
//            }
//            if("20".equals(ryyj) || "30".equals(ryyj) || "40".equals(ryyj)) {
//                sb.append("__入园依据请选择,普通房产，合法居住证明，入园依据类别:居住证标准积分,居住证,双证");
//            }
//        }
//        //3“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证” “境外、护照
//        //
//        if("D".equals(sfzjlx)||"8".equals(sfzjlx)||"9".equals(sfzjlx)||"A".equals(sfzjlx)) {
//
//            if("10".equals(ryyj)) {
//                if("16".equals(ryyjlb) || "17".equals(ryyjlb) ) {
//                } else {
//                    sb.append("__入园依据类别请选择：港澳台,外籍");
//                }
//            }
//            if("50".equals(ryyjlb)) {
//                if("56".equals(ryyjlb) || "57".equals(ryyjlb)) {
//                } else {
//                    sb.append("__入园依据类别请选择：港澳台,外籍");
//                }
//            }
//            if("20".equals(ryyj) || "30".equals(ryyj) || "40".equals(ryyj)) {
//                sb.append("__入园依据请选择,普通房产，合法居住证明，入园依据类别:港澳台,外籍");
//            }
//        }
//        //生源情况
//        String syqk = (String) registerStudent.get("syqk");
//        if(BaseChecks.hasEmptyStr(syqk)){
//            sb.append("__请填写生源情况");
//        }
//        if(!BaseChecks.hasEmptyStr(syqk)){
//            try {
//                DataDict.getChineseValueByCode(EStandTables.生源情况表, syqk);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__生源情况不符合标准表");
//            }
//        }
//        //监护人信息校验：1.监护人学历
//        String jhrxl = (String) registerStudent.get("jhrxl");
//        if(BaseChecks.hasEmptyStr(jhrxl)) {
//            sb.append("__请选择监护人学历");
//        }
//        if(!BaseChecks.hasEmptyStr(jhrxl)) {
//            try {
//                DataDict.getChineseValueByCode(EStandTables.学历表, jhrxl);
//            } catch (DictIsNotFoundException e) {
//                sb.append("__监护人学历不符合标准表");
//            }
//        }
//        String jhrgzdw = (String) registerStudent.get("jhrgzdw");
//        if(BaseChecks.hasEmptyStr(jhrgzdw)) {
//            sb.append("__请填写监护人工作单位");
//        }
//        String jhrjzzlx = (String) registerStudent.get("jhrjzzlx");
//        String jhrzjlx = (String) registerStudent.get("jhrzjlx");
//        if("1".equals(jhrzjlx)) {
//            //当证件类型为居民身份证，校验，户口区县？
//            String jhrhksf = (String) registerStudent.get("jhrhksf");
//            String jhrqx = (String) registerStudent.get("jhrqx");
//            if(BaseChecks.hasEmptyStr(jhrhksf)) {
//                sb.append("__请选择监护人户口省/市");
//            }
//            if(BaseChecks.hasEmptyStr(jhrqx)) {
//                sb.append("__请选择监护人户口市/区县");
//            }
//            //当证件类型为身份证件类型，户口省份不为上海市
//            if(!BaseChecks.hasEmptyStr(jhrhksf)) {
//                if(!"310000".equals(jhrhksf)) {
//                    if(BaseChecks.hasEmptyStr(jhrjzzlx)) {
//                        sb.append("__监护人居住证类型请选择");
//                    }
//                }
//            }
//        }
//        //当证件类型为：为“6香港特区身份证明、7澳门特区身份证明、8台湾居民来往大陆通行证、9境外永久居住证、A护照”时填写。
//        if("6".equals(jhrzjlx)||"7".equals(jhrzjlx)
//                ||"8".equals(jhrzjlx)||"9".equals(jhrzjlx)||"A".equals(jhrzjlx)
//                ||"Z".equals(jhrzjlx)) {
//            if(BaseChecks.hasEmptyStr(jhrjzzlx)) {
//                sb.append("__监护人居住证类型请选择");
//            }
//        }
//        if(!BaseChecks.hasEmptyStr(jhrjzzlx)) {
//            if(!"0".equals(jhrjzzlx)) {
//                String jhrjzzhm = (String) registerStudent.get("jhrjzzhm");
//                if(BaseChecks.hasEmptyStr(jhrjzzhm)) {
//                    sb.append("__请填写监护人居住证号码");
//                }
//                String jhrjzzyxq = (String) registerStudent.get("jhrjzzyxq");
//                if(BaseChecks.hasEmptyStr(jhrjzzyxq)) {
//                    sb.append("__请选择监护人居住证有效时间");
//                }
//            }
//            //监护人居住证类型为上海居住证。
//            if("1".equals(jhrjzzlx)) {
//                String jhrsfbzf = (String) registerStudent.get("jhrsfbzf");
//                //监护人积分是否达标选择
//                if(BaseChecks.hasEmptyStr(jhrsfbzf)) {
//                    sb.append("__请选择监护人居住证是否积分达标");
//                }
//            }
//            //临时居住证
//            if("L".equals(jhrjzzlx)) {
//                String jhrlssj = (String) registerStudent.get("jhrlssj");
//                if(BaseChecks.hasEmptyStr(jhrlssj)) {
//                    sb.append("__请选择监护人临时居住证办证时间");
//                }
//                String jhrsflhjy = (String) registerStudent.get("jhrsflhjy");
//                if(BaseChecks.hasEmptyStr(jhrsflhjy)) {
//                    sb.append("__请选择监护人是否灵活就业");
//                }
//                if(!BaseChecks.hasEmptyStr(jhrsflhjy)) {
//                   if("1".equals(jhrsflhjy)) {
//                       String jhrlhjybh = (String) registerStudent.get("jhrlhjybh");
//                       if(BaseChecks.hasEmptyStr(jhrlhjybh)) {
//                           sb.append("__请填写监护人是否灵活就业");
//                       }
//                       String jhrsyhylb = (String) registerStudent.get("jhrsyhylb");
//                       if(BaseChecks.hasEmptyStr(jhrsyhylb)) {
//                           sb.append("__请选择监护人就业行业类别");
//                       }
//                       String jydjcs = (String) registerStudent.get("jydjcs");
//                       if(BaseChecks.hasEmptyStr(jydjcs)) {
//                           sb.append("__请填写监护人就业登记次数");
//                       }
//                   }
//                }
//            }
//        }
//        return sb.toString();
//    }

    private static final String REG_BIRTHDAY = "(([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))" +"|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-8]))))" +"|((([0-9]{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))0229)";// 生日

    /**
     * 是否符合生日格式
     *
     * @param arg
     * @return
     */
    public static boolean isBirthday(String arg) {
        return arg == null ? false : arg.matches(REG_BIRTHDAY);
    }
    /**
     * 校验身份证唯一
     * 默认返回false，有数据返回true
     * @param params
     * @return
     * @throws SQLException
     */
    public boolean checkRegisterStudentSfzjh(Map<String,Object> params) throws SQLException {
        QueryParams queryRegister = QueryParams.createQueryParams("V_M6_RegisterList_xlj");
        queryRegister.addQueryParams(Parameter.createParameter("sfzjh",params.get("sfzjh")));
        String id = (String) params.get("id");
        if(!BaseChecks.hasEmptyStr(id)) {//修改的时候要去掉本人自己
            queryRegister.addQueryParams(Parameter.createParameter("id",EOperators.不包含,id));
        }
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        try {
            queryRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String, Object> registerMap = baseDaoComponent.selectOneDataByParams(queryRegister);
        if(null!=registerMap) {
            return  true;
        }
        return  false;
    }

    @Override
    public JSONObject addRegisterHk(Map<String, Object> params) throws SQLException, BaseException, ParseException {
        //1.只会收小班学生..
        //首先校验是否在时间范围内.
        Map<String,Object> errorMap = new HashMap<>();
        params.put("opentype","1");//登记
        if(commonService.checkDate(params)){
            errorMap.put("message","不在登记时间范围内");
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            return  rs;
        }
        //1.校验



        return null;
    }

    /**
     * 是否符合身份证格式
     * @param arg
     * @return
     */
    public static boolean isCardId(String arg) {
        return arg == null ? false : arg.matches(REG_CARDID);
    }
    private static final String REG_CARDID = "^[1-9][0-9]{5}(19[0-9]{2}|20[0-9]{2})(0[1-9]|1[0-2])(0[1-9]|[12][0-9]|3[01])[0-9]{3}[0-9X]$";// 身份证号

    /**
     * 获取excel中的数据
     * @param params
     * @return
     * @throws FileTypeNotFoundException
     * @throws IOException
     */
    private List<Map<String,Object>> getImportRegisterList(Map<String, Object> params) throws BaseException, IOException {
        MultipartFile file = (MultipartFile) params.remove("file");
        FileInfoPo infoPo = FileIOComponent.createTempFileForNameAndType(FileIOComponent.IMPORT_TYPE,UUID.randomUUID().toString()+".xlsx");
        String absPath = infoPo.getFileAbsPath();
        //1.0:生成本地文件
        FileUtils.writeByteArrayToFile(new File(absPath), file.getBytes());
        String allHead = (String) params.remove("title");
        ExportExcel excelHelper = ExportExcel.createExportExcel(absPath, allHead);
        return excelHelper.readExcel();
    }

    @Override
    public JSONObject modifyRegister(Map<String, Object> params) throws SQLException, BaseException, ParseException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        String djxx = (String) params.get("djxx");
        Map<String,Object> errorMap = new HashMap<>();
        String userSchoolCode = loginInfo.getSchoolcode();
        if(!djxx.equals(userSchoolCode)) {
            errorMap.put("message","招生学校和采集学校不匹配不能进行修改,需要修改联系采集学校");
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            rs.put("message","招生学校和采集学校不匹配不能进行修改,需要修改联系采集学校");
            return  rs;
        }
        params.put("opentype","1");//登记
        if(!"2".equals(loginInfo.getRoletype())) {
            if(commonService.checkDate(params)){
                errorMap.put("message","不在登记时间范围内,不能修改信息");
                JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
                rs.put("message","不在登记时间范围内,不能修改信息");
                return  rs;
            }
        }

        //2017年3月28日 14:38:58 补录取状态
        String lqzt = (String) params.get("lqzt");
        if("1".equals(lqzt) ||"3".equals(lqzt)) {
            errorMap.put("message","学生"+params.get("xm")+"已经进入业务状态:"+getLqzt(lqzt));
            errorMap.put("status","error");
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            rs.put("message","学生"+params.get("xm")+"已经进入业务状态:"+getLqzt(lqzt));
            return  rs;
        }
        //需要删除学校名称和年级名称
        params.remove("schoolname");
        params.remove("njmc");
        params.remove("checkregister");//是否本校登记必须删除 2017年3月22日17:32:21
        String importCheck = ruleValidationService.checkAddRegisterStudentJs(params);//导入的校验

        if(importCheck.contains("__")) {
            errorMap.put("message",importCheck);
            JSONObject rs = ResponseUtils.createSuccessResponseBody(errorMap);
            rs.put("message",importCheck);
            return  rs;
        }
        params.put("xzzsf","310100");


        //日期转换.2014-01-02 换成20140102
        String id = (String) params.remove("id");
        params.remove("userinfo");//删除用户信息
        UpdateParams updateRegister = UpdateParams.createUpdateParams("T_BAOMINGLUQUINFO");
        Map<String, Object> registerMap = getDate(params);
        registerMap.put("updateuserid",loginInfo.getId());
        registerMap.put("updatetime",Format.getDateTime());
        registerMap.put("checkstatus","1");//修改的全部为校验通过的。
        updateRegister.addParamsForMapIsNull(registerMap);
        updateRegister.addWhereParameter(Parameter.createParameter("id",id));
        baseDaoComponent.updateDataByParams(updateRegister);
        return ResponseUtils.createSuccessResponseBody("修改成功");
    }

    @Override
    public JSONObject removeRegister(Map<String, Object> params) throws SQLException, BaseException, ParseException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        params.put("opentype","1");//登记
        if(!"2".equals(loginInfo.getRoletype())) {
            if(commonService.checkDate(params)){
                JSONObject rs = ResponseUtils.createErrorResponseBody("不在登记时间范围内");
                return  rs;
            }
        }
        //1.查询状态，是否已经录取，或者区县统筹录取
        Map<String,Object> register = new HashMap<>();
        String registerId = (String) params.remove("id");
        register.put("id",registerId);
        register.put("userinfo",loginInfo);
        Map<String, Object> registerMap = getRegisterList(register).get(0);
        String lqzt = (String) registerMap.get("lqzt");
        if(!"0".equals(lqzt)) {
            StringBuffer sb = new StringBuffer();
            sb.append("学生"+registerMap.get("xm")+"已进入业务状态，不能删除该学生信息！");
            sb.append("__业务状态:"+getLqzt(lqzt));
            return ResponseUtils.createSuccessResponseBody(sb);
        }
        //区管删除不需要校验
        if(!loginInfo.getRoletype().equals("2")) {
            //招生学校和采集学校不匹配
            String studentDjxx = (String) registerMap.get("djxx");//采集学校
            String schoolCode = loginInfo.getSchoolcode();
            if(!studentDjxx.equals(schoolCode)) {//采集学校和招生学校对比
                StringBuffer sb = new StringBuffer();
                sb.append("学生"+registerMap.get("xm")+"不是本校登记。不能进行删除");
                //抛出错误，学生已经进入录取业务。不能进行删除
                return ResponseUtils.createSuccessResponseBody(sb);
            }
            //校验是否存在多个学校登记
            if(checkRegisterBaoMing(registerMap,loginInfo)) {
                StringBuffer sb = new StringBuffer();
                sb.append("学生"+registerMap.get("xm")+"已被报别的园区。不能进行删除");
                //抛出错误，学生已经进入录取业务。不能进行删除
                return ResponseUtils.createSuccessResponseBody(sb);
            }
        }
        //删除登记记录
        deletedRegister(registerMap,loginInfo);
        return ResponseUtils.createSuccessResponseBody("删除成功");
    }

    private Boolean checkRegisterBaoMing(Map<String,Object> register,LoginInfo loginInfo) throws SQLException {
        QueryParams queryRegister = QueryParams.createQueryParams("V_M6_getBaoMing_xlj");//视图
        queryRegister.addQueryParams(Parameter.createParameter("bmid",register.get("id")),
                Parameter.createParameter("deleted","0"));//学生id进行查询,使用状态正常的
        try {
            queryRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> registerList = baseDaoComponent.selectDataByParams(queryRegister);
        if ( 1 < registerList.size()) {
            return true;
        }
        return false;
    }

    @Override
    public JSONObject batchImportRemoveRegister(Map<String, Object> params) throws SQLException, IOException, BaseException, ParseException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        params.put("opentype","1");//登记
        if(!"2".equals(loginInfo.getRoletype())) {
            if(commonService.checkDate(params)){
                JSONObject rs = ResponseUtils.createErrorResponseBody("不在登记时间范围内");
                return  rs;
            }
        }
        String title = "{djxx:学校代码,xm:姓名,sfzjh:证件号码}";
        params.put("title",title);
        List<Map<String, Object>> registerList = getImportRegisterList(params);
        //循环匹配删除
        List<Map<String, Object>> successList = new ArrayList<>();
        List<Map<String, Object>> errorList = new ArrayList<>();
        for(Map<String,Object> entity : registerList) {
            //获取姓名+身份证进行查询，然后进行删除。删除有成功和失败，和不允许删除
            String xm = (String) entity.get("xm");
            String djxx = (String) entity.get("djxx");
            String sfzjh = (String) entity.get("sfzjh");
            //校验是否为空
            if(BaseChecks.hasEmptyStr(xm)) {
                entity.put("remark","姓名不能为空");
                errorList.add(entity);
                continue;
            }
            if(BaseChecks.hasEmptyStr(djxx)) {
                entity.put("remark","学校代码不能为空");
                errorList.add(entity);
                continue;
            }
            if(BaseChecks.hasEmptyStr(sfzjh)) {
                entity.put("remark","证件号码不能为空");
                errorList.add(entity);
                continue;
            }
            //查询，传入登记学校，
            Map<String,Object> registerMap = new HashMap<>();
            registerMap.put("xm",xm);
            registerMap.put("schoolcode",djxx);
            registerMap.put("sfzjh",sfzjh);
            //获取原本信息，采集表信息
            QueryParams qeuryRegisterList = QueryParams.createQueryParams("V_M6_RegisterDistrictCode_xlj");
            qeuryRegisterList.addQueryParamsByMap(CollectionUtils.removeEmptyKeyByParams(registerMap));
            try {
                qeuryRegisterList.setDbLog(loginInfo);
            } catch (Exception e) {
                e.printStackTrace();
            }
            Map<String, Object> register  = baseDaoComponent.selectOneDataByParams(qeuryRegisterList);
            if(null!=register) {
                String lqzt = (String) register.get("lqzt");
                if(!"0".equals(lqzt)) {
                    entity.put("remark","已经进入业务状态不能进行删除");
                    errorList.add(entity);
                    continue;
                }
                //区管删除不需要校验
                if(!loginInfo.getRoletype().equals("2")) {
                    //招生和的登记学校不匹配不给删除
                    String studentDjxx = (String) register.get("djxx");
                    if(!studentDjxx.equals(djxx)) {
                        entity.put("remark","登记学校不匹配，不能进行删除");
                        errorList.add(entity);
                        continue;
                    }
                    if(checkRegisterBaoMing(register,loginInfo)) {
                        entity.put("remark","学生已被其他园区登记不能进行删除");
                        errorList.add(entity);
                        continue;
                    }
                }
                //循环删除。没有进入业务状态，可以进行删除
                deletedRegister(register,loginInfo);
                successList.add(entity);
            }
            if(null==register) {
                entity.put("remark","找不到学生信息");
                errorList.add(entity);
                continue;
            }
        }
        String errorTitle = "{djxx:学校代码,xm:姓名,sfzjh:证件号码,remark:备注}";
        Map<String, Object> data = new HashMap<>();
        data.put("url1",getExportUrl(title, successList,"新生登记-批量删除成功"));//成功的url
        data.put("url2",getExportUrl(errorTitle, errorList,"新生登记-批量删除失败"));//失败的url
        Integer errorCount = errorList.size();
        Integer successCount = successList.size();
//        data.put("message","导入成功删除"+successList.size()+"条,失败了"+errorList.size()+"条");
        JSONObject rs = ResponseUtils.createSuccessResponseBody("共"+(successCount+errorCount)+" 条,执行成功"+successCount+"条,失败了"+errorCount+"条", data);
        return rs;
    }

    /**
     * 获取单个信息
     * @param params
     * @return
     * @throws SQLException
     */
    private Map<String,Object> getRegisterDetail(Map<String,Object> params) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) params.remove("userinfo");
        QueryParams queryRegister = QueryParams.createQueryParams("V_M6_RegisterList_xlj");
        queryRegister.addQueryParamsByMap( CollectionUtils.removeEmptyKeyByParams(params));
        try {
            queryRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
       return   baseDaoComponent.selectOneDataByParams(queryRegister);
    }

    private void insertBaoMingRec(Map<String,Object> registerMap,LoginInfo loginInfo) throws SQLException {
        //插入新增or修改记录表
        registerMap.put("insert_time",Format.getDateTime());//新增or修改时间
        registerMap.put("insertuserid",loginInfo.getId());//新增or修改人的id
        InsertParams insertRegisterRec = InsertParams.createInsertParams("T_BAOMINGLUQUINFO_REC");
        insertRegisterRec.addParamsForMap(registerMap);
        try {
            insertRegisterRec.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.insertDataByParams(insertRegisterRec);
    }

    /**
     * 删除记录
     * @param register
     */
    private void deletedRegister(Map<String,Object> register,LoginInfo loginInfo) throws SQLException {
        String registerId = (String) register.get("id");
        //根据id获取登记信息
        QueryParams queryRegister = QueryParams.createQueryParams("T_BAOMINGLUQUINFO");
        queryRegister.addQueryParams(Parameter.createParameter("id",registerId));
        try {
            queryRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String,Object> registerMap = baseDaoComponent.selectOneDataByParams(queryRegister);
        //插入删除前的记录表
        insertBaoMingRec(registerMap,loginInfo);

        //修改报名表
        registerMap.put("bmid",register.get("bmid"));
        updateBaoMing(registerMap,loginInfo);

        //物理删除登记表信息
        DeleteParams rs = DeleteParams.createDeleteParams("T_BAOMINGLUQUINFO",Parameter.createParameter("id",register.get("id")));
        try {
            rs.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        rs.printSelf();
        baseDaoComponent.deleteDataByParams(rs);
    }

    /**deleted,deletedtime
     * 修改删除位
     * @param register
     */
    private void updateBaoMing(Map<String,Object> register,LoginInfo loginInfo) throws SQLException {
        UpdateParams updateParams = UpdateParams.createUpdateParams("t_baominginfo");
        updateParams.addParams(Parameter.createParameter("deleted","1"),
                Parameter.createParameter("deletedtime",Format.getDateTime()),
                Parameter.createParameter("DELETEDUSERID",loginInfo.getId()));
        String roleType = loginInfo.getRoletype();//是否为区管
        if ("2".equals(roleType)) {//区管就全部删除，
            updateParams.addWhereParameter(Parameter.createParameter("bmid",register.get("id")));
        }
        if (!"2".equals(roleType)) {//学校管理员就删除1个
            updateParams.addWhereParameter(Parameter.createParameter("id",register.get("bmid")));
        }
        try {
            updateParams.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.updateDataByParams(updateParams);
    }

    /**
     * 录取状态转换，没有标准表
     * @param lqzt
     * @return
     */
    private String getLqzt(String lqzt) {
        if("1".equals(lqzt)) {
            return "学校录取";
        }
        if("2".equals(lqzt)) {
            return "待统筹";
        }
        if("3".equals(lqzt)) {
            return "区县统筹录取";
        }
        return "";
    }

    @Override
    public JSONObject exportRegister(Map<String, Object> params) throws SQLException, FileTypeNotFoundException, IOException, DictIsNotFoundException {
        params.remove("limit");
        params.remove("offset");
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        String schoolCode = loginInfo.getSchoolcode();
        if(!BaseChecks.hasEmptyStr(schoolCode)) {
            params.put("schoolcode",schoolCode);
        }
        //获取数据
        List<Map<String, Object>> registerList = getRegisterList(params);
//        FileInfoPo fileInfoPo = FileIOComponent.createTempFilePathByType(FileIOComponent.EXPORT_TYPE,"xlsx");
        FileInfoPo fileInfoPo = FileIOComponent.createTempFilePathByType(FileIOComponent.EXPORT_TYPE, "xlsx", "新生登记-列表导出");
        String title = "{schoolname:学校,njmc:年级,xm:姓名,xb:性别,sfzlx:证件类型,sfzjh:证件号码,csrq:出生日期,hksf:户口省份,hkqx:户口区县,ryyj:入园依据,ryyjlb:入园依据类别,zfxz:住房性质,djlx:登记类型,CHECKSTATUS:校验}";
        //转换为中文输出
        List<Map<String, Object>> list = new ArrayList<>();
        for(Map<String,Object> entity : registerList) {
            String xb = (String) entity.get("xb");
            entity.put("xb","1".equals(xb)?"男":"女");
            entity.put("sfzlx",DataDict.getCodeByChineseValueForException(EStandTables.证件类型表, (String) entity.get("sfzlx")));
            String ryyj = (String) entity.get("ryyj");
            if(!BaseChecks.hasEmptyStr(ryyj)) {
                entity.put("ryyj",DataDict.getCodeByChineseValueForException(EStandTables.入园依据表, ryyj));
            }
            String ryyjlb = (String) entity.get("ryyjlb");
            if(!BaseChecks.hasEmptyStr(ryyjlb)) {
                entity.put("ryyjlb",DataDict.getCodeByChineseValueForException(EStandTables.入园依据类别表, ryyjlb));
            }
            String zfxz = (String) entity.get("zfxz");
            if(!BaseChecks.hasEmptyStr(zfxz)) {
                entity.put("zfxz",DataDict.getCodeByChineseValueForException(EStandTables.住房性质表, zfxz));
            }
            String djlx = (String) entity.get("djlx");
            if(!BaseChecks.hasEmptyStr(djlx)) {
                entity.put("djlx",DataDict.getCodeByChineseValueForException(EStandTables.登记类型表,djlx ));
            }
            String hksf = (String) entity.get("hksf");
            if(!BaseChecks.hasEmptyStr(hksf)) {
                entity.put("hksf",DataDict.getCodeByChineseValueForException(EStandTables.省份城市表,hksf ));
            }
            String hkqx = (String) entity.get("hkqx");
            if(!BaseChecks.hasEmptyStr(hkqx)) {
                entity.put("hkqx",DataDict.getCodeByChineseValueForException(EStandTables.省份城市表, hkqx));
            }
            String checkstatus = (String) entity.get("checkstatus");
            if(!BaseChecks.hasEmptyStr(checkstatus)) {
                entity.put("checkstatus",DataDict.getCodeByChineseValueForException(EStandTables.校验状态表, checkstatus));
            }
            list.add(entity);
        }
        String absPath = fileInfoPo.getFileAbsPath();
        ExportExcel eh = ExportExcel.createExportExcel(absPath, title);
        //写入excel数据
        eh.setCurrentData(list);
        eh.writeCurrentData();
        Map<String,Object> data = new DataMap<>();
        data.put("url",fileInfoPo.getFileVirPath());
        JSONObject rs = ResponseUtils.createSuccessResponseBody("导出成功", data);
        return rs;
    }


    @Override
    public JSONObject registerDetail(Map<String, Object> params) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        String id = (String) params.remove("id");
        QueryParams queryRegisterDetail = QueryParams.createQueryParams("V_M6_registerDetail_xlj");//视图
        queryRegisterDetail.addQueryParams(Parameter.createParameter("id",id));
        try {
            queryRegisterDetail.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String, Object> registerDetail = baseDaoComponent.selectOneDataByParams(queryRegisterDetail);
        return  ResponseUtils.createSuccessResponseBody("查看成功", registerDetail);
    }

    @Override
    public JSONObject generateRegister(Map<String, Object> params) throws SQLException, BaseException, IOException, DocumentException {
        //参数校验
        String id = (String) params.get("id");
        if(BaseChecks.hasEmptyStr(id)) throw new BaseException("学生id不能为空");
        LoginInfo loginInfo = (LoginInfo) params.remove("userinfo");
        String districtcode = loginInfo.getDistrictcode();
        if(BaseChecks.hasEmptyStr(districtcode)) throw new BaseException("区县代码不能为空");
        //生成登记表
        String url = "";
        if("310116".equals(districtcode)){
            //查询报名登记的学生
            List<Map<String, Object>> mapList = getRegisterList(params, "V_M6_RegisterList_lrs");
            if (mapList.isEmpty()) throw new BaseException("没有数据");
            url = GenerateRegistrationForm.createRegistrationForm(mapList); //返回下载地址
        }
        if("310109".equals(districtcode)){
            //查询报名登记的学生
            List<Map<String, Object>> mapList = getRegisterList(params, "V_M6_RegisterList_hk_lrs");
            if (mapList.isEmpty()) throw new BaseException("没有数据");
            url = GenerateRegistrationFormHk.createRegistrationFormHk(spliceJhrInfo(mapList)); //返回下载地址
        }
        //封装参数
        Map<String, Object> map = new HashMap<>();
        map.put("url", url);
        return ResponseUtils.createSuccessResponseBody("生成成功", map);
    }

    //拼接家庭成员字段
    private List<Map<String, Object>> spliceJhrInfo(List<Map<String, Object>> oldList) {
        List<Map<String,Object>> newList = new ArrayList<>();
        String stuid = "-1";
        int jtcyNum = 0;
        for (int i = 0, size = oldList.size(); i < size; i++) {
            Map<String, Object> data = oldList.get(i);
            String nextStuid = (String) data.get("id");
            if (!stuid.equals(nextStuid)) {
                jtcyNum = 0;
                stuid = nextStuid;
                newList.add(data);
            } else {
                jtcyNum++;
                Map<String, Object> tempMap = newList.get(newList.size() - 1);
                tempMap.put("jtcygx" + jtcyNum, data.get("jtcygx"));
                tempMap.put("jtcyxm" + jtcyNum, data.get("jtcyxm"));
                tempMap.put("jtcylxfs" + jtcyNum, data.get("jtcylxfs"));
                tempMap.put("jtcygzdw" + jtcyNum, data.get("jtcygzdw"));
                String jhrxm = (String) data.get("jhrxm");
                String jhrgx = (String) data.get("jhrgx");
                if (!BaseChecks.hasEmptyStr(jhrxm, jhrgx)) {
                    tempMap.put("jhrxm", jhrxm);
                    tempMap.put("jhrgx", jhrgx);
                }
            }
        }
        return newList;
    }

    @Override
    public JSONObject batchGeneraterRegistrationForm(Map<String, Object> params) throws SQLException, BaseException, IOException, DocumentException {
        //获取区县代码
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        String districtcode = loginInfo.getDistrictcode();
        if(BaseChecks.hasEmptyStr(districtcode)) throw new BaseException("区县代码不能为空");
        //生成登记表
        String url = "";
        if("310116".equals(districtcode)){
            //查询报名登记的学生
            List<Map<String, Object>> mapList = getRegisterList(params, "V_M6_RegisterList_lrs");
            if (mapList.isEmpty()) throw new BaseException("没有数据");
            url = GenerateRegistrationForm.createRegistrationForm(mapList); //返回下载地址
        }
        if("310109".equals(districtcode)){
            //查询报名登记的学生
            List<Map<String, Object>> mapList = getRegisterList(params, "V_M6_RegisterList_hk_lrs");
            if (mapList.isEmpty()) throw new BaseException("没有数据");
            url = GenerateRegistrationFormHk.createRegistrationFormHk(spliceJhrInfo(mapList)); //返回下载地址
        }
        //封装参数
        Map<String, Object> map = new HashMap<>();
        map.put("url", url);
        return ResponseUtils.createSuccessResponseBody("生成成功", map);
    }

    @Override
    public JSONObject queryRegisterDistrictCode(Map<String, Object> params) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        params.remove("schoolcode");//删除自带学校代码
        String xm = (String) params.get("xm");//姓名
        String zjhm = (String) params.get("sfzjh");//证件号码
        String csrq = (String) params.get("csrq");//出生日期
        if (!BaseChecks.hasEmptyStr(csrq)) {
            csrq = csrq.replace("-","");
            params.put("csrq",csrq);
        }
        //默认加载直接返回空
        if(BaseChecks.hasEmptyStr(zjhm)&&BaseChecks.hasEmptyStr(csrq)) {
            return ResponseUtils.createSuccessResponseBody("查询成功", new ArrayList<>());
        }
        //姓名没有填写，直接返回空
        if(BaseChecks.hasEmptyStr(xm)) {
            return ResponseUtils.createSuccessResponseBody("查询成功", new ArrayList<>());
        }
        //组合条件查询，姓名填写其他的2个条件没有填写，返回空
        if(!BaseChecks.hasEmptyStr(xm)) {
            if(BaseChecks.hasEmptyStr(zjhm)&&BaseChecks.hasEmptyStr(csrq)) {
                return ResponseUtils.createSuccessResponseBody("查询成功",new ArrayList<>());
            }
        }

        QueryParams qeuryRegisterList = QueryParams.createQueryParams("V_M6_RegisterDistrictCode_xlj");
        qeuryRegisterList.addQueryParamsByMap(CollectionUtils.removeEmptyKeyByParams(params));
        try {
            qeuryRegisterList.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> registerList = baseDaoComponent.selectDataByParams(qeuryRegisterList);
        return  ResponseUtils.createSuccessResponseBody("查询成功", registerList);
    }

    @Override
    public JSONObject addRegisterSchool(Map<String, Object> params) throws SQLException, BaseException, ParseException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        params.put("opentype","1");//登记
        if(!"2".equals(loginInfo.getRoletype())) {
            if(commonService.checkDate(params)){
                JSONObject rs = ResponseUtils.createErrorResponseBody("不在登记时间范围内");
                return  rs;
            }
        }
        //校验是否已经被登记，
        Map<String,Object> register = new HashMap<>();
        register.put("id", params.get("id"));////报名学生id
        register.put("schoolcode",loginInfo.getSchoolcode());//报名学校代码，用户自带的代码
        register.put("deleted","0");//是否已经存在有效的报名记录
        QueryParams queryRegister = QueryParams.createQueryParams("V_M6_RegisterList_xlj");
        queryRegister.addQueryParamsByMap(register);
        try {
            queryRegister.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> registerList = baseDaoComponent.selectDataByParams(queryRegister);
        if(0<registerList.size()) throw  new AddRegisterSchoolException();//验证是否已经被本校登记
        //验证是否已经被录取
        QueryParams queryCheck = QueryParams.createQueryParams("V_M6_RegisterList_xlj");
        queryCheck.addQueryParams(Parameter.createParameter("id",params.get("id")));
        try {
            queryCheck.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String,Object> check = baseDaoComponent.selectOneDataByParams(queryCheck);
        if (!"0".equals(check.get("lqzt")))  throw new BaseException("学生:"+check.get("xm")+"已经进入业务状态,状态为："+getLqzt((String) check.get("lqzt")));
        params.put("djxx",loginInfo.getSchoolcode());//报名学校代码，用户自带的代码
        insertBaoMing(params,loginInfo);
        return  ResponseUtils.createSuccessResponseBody("登记成功", "");
    }

    @Override
    public JSONObject cancelRegisterSchool(Map<String, Object> params) throws SQLException {
//        bmid
        LoginInfo loginInfo = (LoginInfo) params.remove("userinfo");

        Map<String,Object> register = new HashMap<>();
        String registerId = (String) params.get("bmid");
        register.put("bmid",registerId);
        //1.是否录取了
        //2.查询的为，区管视图，根据学生的id进行匹配
        QueryParams qeuryRegisterList = QueryParams.createQueryParams("V_M6_RegisterList_xlj");
        qeuryRegisterList.addQueryParamsByMap(CollectionUtils.removeEmptyKeyByParams(register));
        try {
            qeuryRegisterList.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        Map<String, Object> registerMap = baseDaoComponent.selectOneDataByParams(qeuryRegisterList);

        String checkRegister = (String) registerMap.get("checkschool");//是否为本校录取
        if("1".equals(checkRegister)) {
            return  ResponseUtils.createSuccessResponseBody("学生"+registerMap.get("xm")+"已被本校录取不能进行取消报名","");
        }

        String lqzt = (String) registerMap.get("lqzt");
        if (!"0".equals(lqzt)) {
            return  ResponseUtils.createSuccessResponseBody("学生"+registerMap.get("xm")+"已经进入录取阶段，录取状态:"+getLqzt(lqzt),"");
        }
        //取消报名
        updateBaoMing(params,loginInfo);
        return  ResponseUtils.createSuccessResponseBody("取消报名成功","");
    }

    @Override
    public JSONObject getCheckTime(Map<String, Object> params) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) params.get("userinfo");
        params.put("opentype",String.valueOf(params.get("opentype")));//区管跳过
        if(!"2".equals(loginInfo.getRoletype())) {
            JSONObject rs = ResponseUtils.createSuccessResponseBody("获取时间成功",commonService.getCheckDateTime(params));
            return  rs;
        }
        return  ResponseUtils.createErrorResponseBody("区管不要时间",new ArrayList<>() );
    }

}
